<abi-corpus architecture='elf-amd-x86_64' soname='libtcmalloc_and_profiler.so.4'>
  <elf-needed>
    <dependency name='libunwind.so.8'/>
    <dependency name='libpthread.so.0'/>
    <dependency name='libstdc++.so.6'/>
    <dependency name='libm.so.6'/>
    <dependency name='libc.so.6'/>
    <dependency name='ld-linux-x86-64.so.2'/>
    <dependency name='libgcc_s.so.1'/>
  </elf-needed>
  <elf-function-symbols>
    <!-- GetHeapProfile -->
    <elf-symbol name='GetHeapProfile' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfilerDump -->
    <elf-symbol name='HeapProfilerDump' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfilerStart -->
    <elf-symbol name='HeapProfilerStart' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfilerStop -->
    <elf-symbol name='HeapProfilerStop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- IsHeapProfilerRunning -->
    <elf-symbol name='IsHeapProfilerRunning' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_GetAllocatedSize -->
    <elf-symbol name='MallocExtension_GetAllocatedSize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_GetEstimatedAllocatedSize -->
    <elf-symbol name='MallocExtension_GetEstimatedAllocatedSize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_GetNumericProperty -->
    <elf-symbol name='MallocExtension_GetNumericProperty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_GetOwnership -->
    <elf-symbol name='MallocExtension_GetOwnership' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_GetStats -->
    <elf-symbol name='MallocExtension_GetStats' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_MallocMemoryStats -->
    <elf-symbol name='MallocExtension_MallocMemoryStats' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_MarkThreadBusy -->
    <elf-symbol name='MallocExtension_MarkThreadBusy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_MarkThreadIdle -->
    <elf-symbol name='MallocExtension_MarkThreadIdle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_ReleaseFreeMemory -->
    <elf-symbol name='MallocExtension_ReleaseFreeMemory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_ReleaseToSystem -->
    <elf-symbol name='MallocExtension_ReleaseToSystem' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_SetNumericProperty -->
    <elf-symbol name='MallocExtension_SetNumericProperty' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_VerifyAllMemory -->
    <elf-symbol name='MallocExtension_VerifyAllMemory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_VerifyArrayNewMemory -->
    <elf-symbol name='MallocExtension_VerifyArrayNewMemory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_VerifyMallocMemory -->
    <elf-symbol name='MallocExtension_VerifyMallocMemory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension_VerifyNewMemory -->
    <elf-symbol name='MallocExtension_VerifyNewMemory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddDeleteHook -->
    <elf-symbol name='MallocHook_AddDeleteHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddMmapHook -->
    <elf-symbol name='MallocHook_AddMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddMremapHook -->
    <elf-symbol name='MallocHook_AddMremapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddMunmapHook -->
    <elf-symbol name='MallocHook_AddMunmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddNewHook -->
    <elf-symbol name='MallocHook_AddNewHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddPreMmapHook -->
    <elf-symbol name='MallocHook_AddPreMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddPreSbrkHook -->
    <elf-symbol name='MallocHook_AddPreSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_AddSbrkHook -->
    <elf-symbol name='MallocHook_AddSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_GetCallerStackTrace -->
    <elf-symbol name='MallocHook_GetCallerStackTrace' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_InitAtFirstAllocation_HeapLeakChecker -->
    <elf-symbol name='MallocHook_InitAtFirstAllocation_HeapLeakChecker' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveDeleteHook -->
    <elf-symbol name='MallocHook_RemoveDeleteHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveMmapHook -->
    <elf-symbol name='MallocHook_RemoveMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveMmapReplacement -->
    <elf-symbol name='MallocHook_RemoveMmapReplacement' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveMremapHook -->
    <elf-symbol name='MallocHook_RemoveMremapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveMunmapHook -->
    <elf-symbol name='MallocHook_RemoveMunmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveMunmapReplacement -->
    <elf-symbol name='MallocHook_RemoveMunmapReplacement' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveNewHook -->
    <elf-symbol name='MallocHook_RemoveNewHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemovePreMmapHook -->
    <elf-symbol name='MallocHook_RemovePreMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemovePreSbrkHook -->
    <elf-symbol name='MallocHook_RemovePreSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_RemoveSbrkHook -->
    <elf-symbol name='MallocHook_RemoveSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetDeleteHook -->
    <elf-symbol name='MallocHook_SetDeleteHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetMmapHook -->
    <elf-symbol name='MallocHook_SetMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetMmapReplacement -->
    <elf-symbol name='MallocHook_SetMmapReplacement' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetMremapHook -->
    <elf-symbol name='MallocHook_SetMremapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetMunmapHook -->
    <elf-symbol name='MallocHook_SetMunmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetMunmapReplacement -->
    <elf-symbol name='MallocHook_SetMunmapReplacement' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetNewHook -->
    <elf-symbol name='MallocHook_SetNewHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetPreMmapHook -->
    <elf-symbol name='MallocHook_SetPreMmapHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetPreSbrkHook -->
    <elf-symbol name='MallocHook_SetPreSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook_SetSbrkHook -->
    <elf-symbol name='MallocHook_SetSbrkHook' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandlerGetState -->
    <elf-symbol name='ProfileHandlerGetState' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandlerRegisterCallback -->
    <elf-symbol name='ProfileHandlerRegisterCallback' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandlerRegisterThread -->
    <elf-symbol name='ProfileHandlerRegisterThread' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandlerReset -->
    <elf-symbol name='ProfileHandlerReset' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandlerUnregisterCallback -->
    <elf-symbol name='ProfileHandlerUnregisterCallback' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerDisable -->
    <elf-symbol name='ProfilerDisable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerEnable -->
    <elf-symbol name='ProfilerEnable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerFlush -->
    <elf-symbol name='ProfilerFlush' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerGetCurrentState -->
    <elf-symbol name='ProfilerGetCurrentState' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerRegisterThread -->
    <elf-symbol name='ProfilerRegisterThread' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerStart -->
    <elf-symbol name='ProfilerStart' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerStartWithOptions -->
    <elf-symbol name='ProfilerStartWithOptions' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilerStop -->
    <elf-symbol name='ProfilerStop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfilingIsEnabledForAllThreads -->
    <elf-symbol name='ProfilingIsEnabledForAllThreads' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RunningOnValgrind -->
    <elf-symbol name='RunningOnValgrind' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocGetenvSafe -->
    <elf-symbol name='TCMallocGetenvSafe' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_ListAllProcessThreads -->
    <elf-symbol name='TCMalloc_ListAllProcessThreads' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_ResumeAllProcessThreads -->
    <elf-symbol name='TCMalloc_ResumeAllProcessThreads' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ValgrindSlowdown -->
    <elf-symbol name='ValgrindSlowdown' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetStackTrace(void**, int, int) -->
    <elf-symbol name='_Z13GetStackTracePPvii' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetStackFrames(void**, int*, int, int) -->
    <elf-symbol name='_Z14GetStackFramesPPvPiii' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CyclesPerSecond() -->
    <elf-symbol name='_Z15CyclesPerSecondv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HasPosixThreads() -->
    <elf-symbol name='_Z15HasPosixThreadsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetenvBeforeMain(char const*) -->
    <elf-symbol name='_Z16GetenvBeforeMainPKc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RawOpenForWriting(char const*) -->
    <elf-symbol name='_Z17RawOpenForWritingPKc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetUniquePathFromEnv(char const*, char*) -->
    <elf-symbol name='_Z20GetUniquePathFromEnvPKcPc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- InitSystemAllocators() -->
    <elf-symbol name='_Z20InitSystemAllocatorsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SleepForMilliseconds(int) -->
    <elf-symbol name='_Z20SleepForMillisecondsi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_SystemAlloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_Z20TCMalloc_SystemAllocmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_SystemCommit(void*, unsigned long) -->
    <elf-symbol name='_Z21TCMalloc_SystemCommitPvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_SystemRelease(void*, unsigned long) -->
    <elf-symbol name='_Z22TCMalloc_SystemReleasePvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- perftools_pthread_once(int*, void (*)()) -->
    <elf-symbol name='_Z22perftools_pthread_oncePiPFvvE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetStackTraceWithContext(void**, int, int, void const*) -->
    <elf-symbol name='_Z24GetStackTraceWithContextPPviiPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tc_get_sysalloc_override(SysAllocator*) -->
    <elf-symbol name='_Z24tc_get_sysalloc_overrideP12SysAllocator' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GetStackFramesWithContext(void**, int*, int, int, void const*) -->
    <elf-symbol name='_Z25GetStackFramesWithContextPPvPiiiPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- perftools_pthread_key_create(unsigned int*, void (*)(void*)) -->
    <elf-symbol name='_Z28perftools_pthread_key_createPjPFvPvE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- perftools_pthread_key_delete(unsigned int) -->
    <elf-symbol name='_Z28perftools_pthread_key_deletej' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- perftools_pthread_getspecific(unsigned int) -->
    <elf-symbol name='_Z29perftools_pthread_getspecificj' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- perftools_pthread_setspecific(unsigned int, void*) -->
    <elf-symbol name='_Z29perftools_pthread_setspecificjPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker_RunHeapCleanups() -->
    <elf-symbol name='_Z31HeapLeakChecker_RunHeapCleanupsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker_AfterDestructors() -->
    <elf-symbol name='_Z32HeapLeakChecker_AfterDestructorsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker_InternalInitStart() -->
    <elf-symbol name='_Z33HeapLeakChecker_InternalInitStartv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker_BeforeConstructors() -->
    <elf-symbol name='_Z34HeapLeakChecker_BeforeConstructorsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- NumCPUs() -->
    <elf-symbol name='_Z7NumCPUsv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RAW_LOG(int, char const*, ...) -->
    <elf-symbol name='_Z7RAW_LOGiPKcz' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RAW_VLOG(int, char const*, ...) -->
    <elf-symbol name='_Z8RAW_VLOGiPKcz' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RawClose(int) -->
    <elf-symbol name='_Z8RawClosei' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- RawWrite(int, char const*, unsigned long) -->
    <elf-symbol name='_Z8RawWriteiPKcm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LogPrintf(int, char const*, __va_list_tag*) -->
    <elf-symbol name='_Z9LogPrintfiPKcP13__va_list_tag' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::Insert(void const*, HeapProfileTable::AllocValue) -->
    <elf-symbol name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE6InsertEPKvS1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::AddressMap(void* (*)(unsigned long), void (*)(void*)) -->
    <elf-symbol name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEEC1EPFPvmEPFvS3_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::AddressMap(void* (*)(unsigned long), void (*)(void*)) -->
    <elf-symbol name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEEC2EPFPvmEPFvS3_E' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN10AddressMapIN16HeapProfileTable10AllocValueEEC1EPFPvmEPFvS3_E' is-defined='yes'/>
    <!-- MallocHook::UnhookedMMap(void*, unsigned long, int, int, int, long) -->
    <elf-symbol name='_ZN10MallocHook12UnhookedMMapEPvmiiil' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::UnhookedMUnmap(void*, unsigned long) -->
    <elf-symbol name='_ZN10MallocHook14UnhookedMUnmapEPvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeNewHookSlow(void const*, unsigned long) -->
    <elf-symbol name='_ZN10MallocHook17InvokeNewHookSlowEPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeMmapHookSlow(void const*, void const*, unsigned long, int, int, int, long) -->
    <elf-symbol name='_ZN10MallocHook18InvokeMmapHookSlowEPKvS1_miiil' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeSbrkHookSlow(void const*, long) -->
    <elf-symbol name='_ZN10MallocHook18InvokeSbrkHookSlowEPKvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeDeleteHookSlow(void const*) -->
    <elf-symbol name='_ZN10MallocHook20InvokeDeleteHookSlowEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeMremapHookSlow(void const*, void const*, unsigned long, unsigned long, int, void const*) -->
    <elf-symbol name='_ZN10MallocHook20InvokeMremapHookSlowEPKvS1_mmiS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeMunmapHookSlow(void const*, unsigned long) -->
    <elf-symbol name='_ZN10MallocHook20InvokeMunmapHookSlowEPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokePreMmapHookSlow(void const*, unsigned long, int, int, int, long) -->
    <elf-symbol name='_ZN10MallocHook21InvokePreMmapHookSlowEPKvmiiil' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokePreSbrkHookSlow(long) -->
    <elf-symbol name='_ZN10MallocHook21InvokePreSbrkHookSlowEl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeMmapReplacementSlow(void const*, unsigned long, int, int, int, long, void**) -->
    <elf-symbol name='_ZN10MallocHook25InvokeMmapReplacementSlowEPKvmiiilPPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocHook::InvokeMunmapReplacementSlow(void const*, unsigned long, int*) -->
    <elf-symbol name='_ZN10MallocHook27InvokeMunmapReplacementSlowEPKvmPi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::FlushTable() -->
    <elf-symbol name='_ZN11CpuProfiler10FlushTableEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::prof_handler(int, siginfo*, void*, void*) -->
    <elf-symbol name='_ZN11CpuProfiler12prof_handlerEiP7siginfoPvS2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::EnableHandler() -->
    <elf-symbol name='_ZN11CpuProfiler13EnableHandlerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::DisableHandler() -->
    <elf-symbol name='_ZN11CpuProfiler14DisableHandlerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::GetCurrentState(ProfilerState*) -->
    <elf-symbol name='_ZN11CpuProfiler15GetCurrentStateEP13ProfilerState' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::Stop() -->
    <elf-symbol name='_ZN11CpuProfiler4StopEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::Start(char const*, ProfilerOptions const*) -->
    <elf-symbol name='_ZN11CpuProfiler5StartEPKcPK15ProfilerOptions' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::Enabled() -->
    <elf-symbol name='_ZN11CpuProfiler7EnabledEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::CpuProfiler() -->
    <elf-symbol name='_ZN11CpuProfilerC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11CpuProfilerC2Ev' is-defined='yes'/>
    <!-- CpuProfiler::CpuProfiler() -->
    <elf-symbol name='_ZN11CpuProfilerC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::~CpuProfiler() -->
    <elf-symbol name='_ZN11CpuProfilerD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11CpuProfilerD2Ev' is-defined='yes'/>
    <!-- CpuProfiler::~CpuProfiler() -->
    <elf-symbol name='_ZN11CpuProfilerD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapCleaner::RunHeapCleanups() -->
    <elf-symbol name='_ZN11HeapCleaner15RunHeapCleanupsEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapCleaner::HeapCleaner(void (*)()) -->
    <elf-symbol name='_ZN11HeapCleanerC1EPFvvE' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11HeapCleanerC2EPFvvE' is-defined='yes'/>
    <!-- HeapCleaner::HeapCleaner(void (*)()) -->
    <elf-symbol name='_ZN11HeapCleanerC2EPFvvE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::FlushTable() -->
    <elf-symbol name='_ZN11ProfileData10FlushTableEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::FlushEvicted() -->
    <elf-symbol name='_ZN11ProfileData12FlushEvictedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Add(int, void const* const*) -->
    <elf-symbol name='_ZN11ProfileData3AddEiPKPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Stop() -->
    <elf-symbol name='_ZN11ProfileData4StopEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Evict(ProfileData::Entry const&) -->
    <elf-symbol name='_ZN11ProfileData5EvictERKNS_5EntryE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Reset() -->
    <elf-symbol name='_ZN11ProfileData5ResetEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Start(char const*, ProfileData::Options const&) -->
    <elf-symbol name='_ZN11ProfileData5StartEPKcRKNS_7OptionsE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::Options::Options() -->
    <elf-symbol name='_ZN11ProfileData7OptionsC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11ProfileData7OptionsC2Ev' is-defined='yes'/>
    <!-- ProfileData::Options::Options() -->
    <elf-symbol name='_ZN11ProfileData7OptionsC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::ProfileData() -->
    <elf-symbol name='_ZN11ProfileDataC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11ProfileDataC2Ev' is-defined='yes'/>
    <!-- ProfileData::ProfileData() -->
    <elf-symbol name='_ZN11ProfileDataC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::~ProfileData() -->
    <elf-symbol name='_ZN11ProfileDataD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN11ProfileDataD2Ev' is-defined='yes'/>
    <!-- ProfileData::~ProfileData() -->
    <elf-symbol name='_ZN11ProfileDataD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SymbolTable::Add(void const*) -->
    <elf-symbol name='_ZN11SymbolTable3AddEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SymbolTable::GetSymbol(void const*) -->
    <elf-symbol name='_ZN11SymbolTable9GetSymbolEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SymbolTable::Symbolize() -->
    <elf-symbol name='_ZN11SymbolTable9SymbolizeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SysAllocator::~SysAllocator() -->
    <elf-symbol name='_ZN12SysAllocatorD0Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SysAllocator::~SysAllocator() -->
    <elf-symbol name='_ZN12SysAllocatorD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN12SysAllocatorD2Ev' is-defined='yes'/>
    <!-- SysAllocator::~SysAllocator() -->
    <elf-symbol name='_ZN12SysAllocatorD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::DeleteArena(LowLevelAlloc::Arena*) -->
    <elf-symbol name='_ZN13LowLevelAlloc11DeleteArenaEPNS_5ArenaE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::DefaultArena() -->
    <elf-symbol name='_ZN13LowLevelAlloc12DefaultArenaEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::AllocWithArena(unsigned long, LowLevelAlloc::Arena*) -->
    <elf-symbol name='_ZN13LowLevelAlloc14AllocWithArenaEmPNS_5ArenaE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::Free(void*) -->
    <elf-symbol name='_ZN13LowLevelAlloc4FreeEPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::Alloc(unsigned long) -->
    <elf-symbol name='_ZN13LowLevelAlloc5AllocEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- LowLevelAlloc::NewArena(int, LowLevelAlloc::Arena*) -->
    <elf-symbol name='_ZN13LowLevelAlloc8NewArenaEiPNS_5ArenaE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocGuard::TCMallocGuard() -->
    <elf-symbol name='_ZN13TCMallocGuardC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN13TCMallocGuardC2Ev' is-defined='yes'/>
    <!-- TCMallocGuard::TCMallocGuard() -->
    <elf-symbol name='_ZN13TCMallocGuardC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocGuard::~TCMallocGuard() -->
    <elf-symbol name='_ZN13TCMallocGuardD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN13TCMallocGuardD2Ev' is-defined='yes'/>
    <!-- TCMallocGuard::~TCMallocGuard() -->
    <elf-symbol name='_ZN13TCMallocGuardD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::StartTimer() -->
    <elf-symbol name='_ZN14ProfileHandler10StartTimerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::EnableHandler() -->
    <elf-symbol name='_ZN14ProfileHandler13EnableHandlerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::SignalHandler(int, siginfo*, void*) -->
    <elf-symbol name='_ZN14ProfileHandler13SignalHandlerEiP7siginfoPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::DisableHandler() -->
    <elf-symbol name='_ZN14ProfileHandler14DisableHandlerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::IsTimerRunning() -->
    <elf-symbol name='_ZN14ProfileHandler14IsTimerRunningEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::RegisterThread() -->
    <elf-symbol name='_ZN14ProfileHandler14RegisterThreadEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::RegisterCallback(void (*)(int, siginfo*, void*, void*), void*) -->
    <elf-symbol name='_ZN14ProfileHandler16RegisterCallbackEPFviP7siginfoPvS2_ES2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::UnregisterCallback(ProfileHandlerToken*) -->
    <elf-symbol name='_ZN14ProfileHandler18UnregisterCallbackEP19ProfileHandlerToken' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::IsSignalHandlerAvailable() -->
    <elf-symbol name='_ZN14ProfileHandler24IsSignalHandlerAvailableEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::Init() -->
    <elf-symbol name='_ZN14ProfileHandler4InitEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::Reset() -->
    <elf-symbol name='_ZN14ProfileHandler5ResetEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::GetState(ProfileHandlerState*) -->
    <elf-symbol name='_ZN14ProfileHandler8GetStateEP19ProfileHandlerState' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::Instance() -->
    <elf-symbol name='_ZN14ProfileHandler8InstanceEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::StopTimer() -->
    <elf-symbol name='_ZN14ProfileHandler9StopTimerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::ProfileHandler() -->
    <elf-symbol name='_ZN14ProfileHandlerC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN14ProfileHandlerC2Ev' is-defined='yes'/>
    <!-- ProfileHandler::ProfileHandler() -->
    <elf-symbol name='_ZN14ProfileHandlerC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::~ProfileHandler() -->
    <elf-symbol name='_ZN14ProfileHandlerD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN14ProfileHandlerD2Ev' is-defined='yes'/>
    <!-- ProfileHandler::~ProfileHandler() -->
    <elf-symbol name='_ZN14ProfileHandlerD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLockHolder::SpinLockHolder(SpinLock*) -->
    <elf-symbol name='_ZN14SpinLockHolderC1EP8SpinLock' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLockHolder::SpinLockHolder(SpinLock*) -->
    <elf-symbol name='_ZN14SpinLockHolderC2EP8SpinLock' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN14SpinLockHolderC1EP8SpinLock' is-defined='yes'/>
    <!-- SpinLockHolder::~SpinLockHolder() -->
    <elf-symbol name='_ZN14SpinLockHolderD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN14SpinLockHolderD2Ev' is-defined='yes'/>
    <!-- SpinLockHolder::~SpinLockHolder() -->
    <elf-symbol name='_ZN14SpinLockHolderD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::GlobalChecker() -->
    <elf-symbol name='_ZN15HeapLeakChecker13GlobalCheckerEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::NoGlobalLeaks() -->
    <elf-symbol name='_ZN15HeapLeakChecker13NoGlobalLeaksEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DoIgnoreObject(void const*) -->
    <elf-symbol name='_ZN15HeapLeakChecker14DoIgnoreObjectEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::GetAllocCaller(void*) -->
    <elf-symbol name='_ZN15HeapLeakChecker14GetAllocCallerEPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::UnIgnoreObject(void const*) -->
    <elf-symbol name='_ZN15HeapLeakChecker14UnIgnoreObjectEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DisableChecksIn(char const*) -->
    <elf-symbol name='_ZN15HeapLeakChecker15DisableChecksInEPKc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DoMainHeapCheck() -->
    <elf-symbol name='_ZN15HeapLeakChecker15DoMainHeapCheckEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::CancelGlobalCheck() -->
    <elf-symbol name='_ZN15HeapLeakChecker17CancelGlobalCheckEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::UseProcMapsLocked(HeapLeakChecker::ProcMapsTask) -->
    <elf-symbol name='_ZN15HeapLeakChecker17UseProcMapsLockedENS_12ProcMapsTaskE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::TurnItselfOffLocked() -->
    <elf-symbol name='_ZN15HeapLeakChecker19TurnItselfOffLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::MakeProfileNameLocked() -->
    <elf-symbol name='_ZN15HeapLeakChecker21MakeProfileNameLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::IgnoreLiveObjectsLocked(char const*, char const*) -->
    <elf-symbol name='_ZN15HeapLeakChecker23IgnoreLiveObjectsLockedEPKcS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::IgnoreLiveThreadsLocked(void*, int, int*, __va_list_tag*) -->
    <elf-symbol name='_ZN15HeapLeakChecker23IgnoreLiveThreadsLockedEPviPiP13__va_list_tag' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::BeforeConstructorsLocked() -->
    <elf-symbol name='_ZN15HeapLeakChecker24BeforeConstructorsLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DisableChecksFromToLocked(void const*, void const*, int) -->
    <elf-symbol name='_ZN15HeapLeakChecker25DisableChecksFromToLockedEPKvS1_i' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DisableLibraryAllocsLocked(char const*, unsigned long, unsigned long) -->
    <elf-symbol name='_ZN15HeapLeakChecker26DisableLibraryAllocsLockedEPKcmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::IgnoreAllLiveObjectsLocked(void const*) -->
    <elf-symbol name='_ZN15HeapLeakChecker26IgnoreAllLiveObjectsLockedEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::NoGlobalLeaksMaybeSymbolize(HeapLeakChecker::ShouldSymbolize) -->
    <elf-symbol name='_ZN15HeapLeakChecker27NoGlobalLeaksMaybeSymbolizeENS_15ShouldSymbolizeE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::IgnoreNonThreadLiveObjectsLocked() -->
    <elf-symbol name='_ZN15HeapLeakChecker32IgnoreNonThreadLiveObjectsLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Create(char const*, bool) -->
    <elf-symbol name='_ZN15HeapLeakChecker6CreateEPKcb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Disabler::Disabler() -->
    <elf-symbol name='_ZN15HeapLeakChecker8DisablerC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15HeapLeakChecker8DisablerC2Ev' is-defined='yes'/>
    <!-- HeapLeakChecker::Disabler::Disabler() -->
    <elf-symbol name='_ZN15HeapLeakChecker8DisablerC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Disabler::~Disabler() -->
    <elf-symbol name='_ZN15HeapLeakChecker8DisablerD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15HeapLeakChecker8DisablerD2Ev' is-defined='yes'/>
    <!-- HeapLeakChecker::Disabler::~Disabler() -->
    <elf-symbol name='_ZN15HeapLeakChecker8DisablerD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::IsActive() -->
    <elf-symbol name='_ZN15HeapLeakChecker8IsActiveEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Allocator::Free(void*) -->
    <elf-symbol name='_ZN15HeapLeakChecker9Allocator4FreeEPv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Allocator::Allocate(unsigned long) -->
    <elf-symbol name='_ZN15HeapLeakChecker9Allocator8AllocateEm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::DoNoLeaks(HeapLeakChecker::ShouldSymbolize) -->
    <elf-symbol name='_ZN15HeapLeakChecker9DoNoLeaksENS_15ShouldSymbolizeE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::HeapLeakChecker(char const*) -->
    <elf-symbol name='_ZN15HeapLeakCheckerC1EPKc' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15HeapLeakCheckerC2EPKc' is-defined='yes'/>
    <!-- HeapLeakChecker::HeapLeakChecker() -->
    <elf-symbol name='_ZN15HeapLeakCheckerC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15HeapLeakCheckerC2Ev' is-defined='yes'/>
    <!-- HeapLeakChecker::HeapLeakChecker(char const*) -->
    <elf-symbol name='_ZN15HeapLeakCheckerC2EPKc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::HeapLeakChecker() -->
    <elf-symbol name='_ZN15HeapLeakCheckerC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::~HeapLeakChecker() -->
    <elf-symbol name='_ZN15HeapLeakCheckerD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15HeapLeakCheckerD2Ev' is-defined='yes'/>
    <!-- HeapLeakChecker::~HeapLeakChecker() -->
    <elf-symbol name='_ZN15HeapLeakCheckerD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::Initialize() -->
    <elf-symbol name='_ZN15MallocExtension10InitializeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetOwnership(void const*) -->
    <elf-symbol name='_ZN15MallocExtension12GetOwnershipEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetHeapSample(std::string*) -->
    <elf-symbol name='_ZN15MallocExtension13GetHeapSampleEPSs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::MarkThreadBusy() -->
    <elf-symbol name='_ZN15MallocExtension14MarkThreadBusyEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::MarkThreadIdle() -->
    <elf-symbol name='_ZN15MallocExtension14MarkThreadIdleEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::ReadStackTraces(int*) -->
    <elf-symbol name='_ZN15MallocExtension15ReadStackTracesEPi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::ReleaseToSystem(unsigned long) -->
    <elf-symbol name='_ZN15MallocExtension15ReleaseToSystemEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::VerifyAllMemory() -->
    <elf-symbol name='_ZN15MallocExtension15VerifyAllMemoryEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::VerifyNewMemory(void const*) -->
    <elf-symbol name='_ZN15MallocExtension15VerifyNewMemoryEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetAllocatedSize(void const*) -->
    <elf-symbol name='_ZN15MallocExtension16GetAllocatedSizeEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*) -->
    <elf-symbol name='_ZN15MallocExtension16GetFreeListSizesEPSt6vectorINS_12FreeListInfoESaIS1_EE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::MallocMemoryStats(int*, unsigned long*, int*) -->
    <elf-symbol name='_ZN15MallocExtension17MallocMemoryStatsEPiPmS0_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::ReleaseFreeMemory() -->
    <elf-symbol name='_ZN15MallocExtension17ReleaseFreeMemoryEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetNumericProperty(char const*, unsigned long*) -->
    <elf-symbol name='_ZN15MallocExtension18GetNumericPropertyEPKcPm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetSystemAllocator() -->
    <elf-symbol name='_ZN15MallocExtension18GetSystemAllocatorEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::SetNumericProperty(char const*, unsigned long) -->
    <elf-symbol name='_ZN15MallocExtension18SetNumericPropertyEPKcm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::SetSystemAllocator(SysAllocator*) -->
    <elf-symbol name='_ZN15MallocExtension18SetSystemAllocatorEP12SysAllocator' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::VerifyMallocMemory(void const*) -->
    <elf-symbol name='_ZN15MallocExtension18VerifyMallocMemoryEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetHeapGrowthStacks(std::string*) -->
    <elf-symbol name='_ZN15MallocExtension19GetHeapGrowthStacksEPSs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetMemoryReleaseRate() -->
    <elf-symbol name='_ZN15MallocExtension20GetMemoryReleaseRateEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::SetMemoryReleaseRate(double) -->
    <elf-symbol name='_ZN15MallocExtension20SetMemoryReleaseRateEd' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::VerifyArrayNewMemory(void const*) -->
    <elf-symbol name='_ZN15MallocExtension20VerifyArrayNewMemoryEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetEstimatedAllocatedSize(unsigned long) -->
    <elf-symbol name='_ZN15MallocExtension25GetEstimatedAllocatedSizeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::ReadHeapGrowthStackTraces() -->
    <elf-symbol name='_ZN15MallocExtension25ReadHeapGrowthStackTracesEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::Ranges(void*, void (*)(void*, base::MallocRange const*)) -->
    <elf-symbol name='_ZN15MallocExtension6RangesEPvPFvS0_PKN4base11MallocRangeEE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::GetStats(char*, int) -->
    <elf-symbol name='_ZN15MallocExtension8GetStatsEPci' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::Register(MallocExtension*) -->
    <elf-symbol name='_ZN15MallocExtension8RegisterEPS_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::instance() -->
    <elf-symbol name='_ZN15MallocExtension8instanceEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::~MallocExtension() -->
    <elf-symbol name='_ZN15MallocExtensionD0Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MallocExtension::~MallocExtension() -->
    <elf-symbol name='_ZN15MallocExtensionD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN15MallocExtensionD2Ev' is-defined='yes'/>
    <!-- MallocExtension::~MallocExtension() -->
    <elf-symbol name='_ZN15MallocExtensionD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::FindRegion(unsigned long, MemoryRegionMap::Region*) -->
    <elf-symbol name='_ZN15MemoryRegionMap10FindRegionEmPNS_6RegionE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::LockIsHeld() -->
    <elf-symbol name='_ZN15MemoryRegionMap10LockIsHeldEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::MremapHook(void const*, void const*, unsigned long, unsigned long, int, void const*) -->
    <elf-symbol name='_ZN15MemoryRegionMap10MremapHookEPKvS1_mmiS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::MunmapHook(void const*, unsigned long) -->
    <elf-symbol name='_ZN15MemoryRegionMap10MunmapHookEPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::LogAllLocked() -->
    <elf-symbol name='_ZN15MemoryRegionMap12LogAllLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::EndRegionLocked() -->
    <elf-symbol name='_ZN15MemoryRegionMap15EndRegionLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::BeginRegionLocked() -->
    <elf-symbol name='_ZN15MemoryRegionMap17BeginRegionLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::IsRecordingLocked() -->
    <elf-symbol name='_ZN15MemoryRegionMap17IsRecordingLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::DoFindRegionLocked(unsigned long) -->
    <elf-symbol name='_ZN15MemoryRegionMap18DoFindRegionLockedEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::InsertRegionLocked(MemoryRegionMap::Region const&) -->
    <elf-symbol name='_ZN15MemoryRegionMap18InsertRegionLockedERKNS_6RegionE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::RecordRegionRemoval(void const*, unsigned long) -->
    <elf-symbol name='_ZN15MemoryRegionMap19RecordRegionRemovalEPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::DoInsertRegionLocked(MemoryRegionMap::Region const&) -->
    <elf-symbol name='_ZN15MemoryRegionMap20DoInsertRegionLockedERKNS_6RegionE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::RecordRegionAddition(void const*, unsigned long) -->
    <elf-symbol name='_ZN15MemoryRegionMap20RecordRegionAdditionEPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::FindAndMarkStackRegion(unsigned long, MemoryRegionMap::Region*) -->
    <elf-symbol name='_ZN15MemoryRegionMap22FindAndMarkStackRegionEmPNS_6RegionE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::HandleSavedRegionsLocked(void (*)(MemoryRegionMap::Region const&)) -->
    <elf-symbol name='_ZN15MemoryRegionMap24HandleSavedRegionsLockedEPFvRKNS_6RegionEE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::RestoreSavedBucketsLocked() -->
    <elf-symbol name='_ZN15MemoryRegionMap25RestoreSavedBucketsLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::RecordRegionRemovalInBucket(int, void const* const*, unsigned long) -->
    <elf-symbol name='_ZN15MemoryRegionMap27RecordRegionRemovalInBucketEiPKPKvm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::Init(int, bool) -->
    <elf-symbol name='_ZN15MemoryRegionMap4InitEib' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::Lock() -->
    <elf-symbol name='_ZN15MemoryRegionMap4LockEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::Unlock() -->
    <elf-symbol name='_ZN15MemoryRegionMap6UnlockEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::MmapHook(void const*, void const*, unsigned long, int, int, int, long) -->
    <elf-symbol name='_ZN15MemoryRegionMap8MmapHookEPKvS1_miiil' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::SbrkHook(void const*, long) -->
    <elf-symbol name='_ZN15MemoryRegionMap8SbrkHookEPKvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::Shutdown() -->
    <elf-symbol name='_ZN15MemoryRegionMap8ShutdownEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::GetBucket(int, void const* const*) -->
    <elf-symbol name='_ZN15MemoryRegionMap9GetBucketEiPKPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::MarkAsLive(void const*) -->
    <elf-symbol name='_ZN16HeapProfileTable10MarkAsLiveEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::RecordFree(void const*) -->
    <elf-symbol name='_ZN16HeapProfileTable10RecordFreeEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::RecordAlloc(void const*, unsigned long, int, void const* const*) -->
    <elf-symbol name='_ZN16HeapProfileTable11RecordAllocEPKvmiPKS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::AddIfNonLive(void const*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*) -->
    <elf-symbol name='_ZN16HeapProfileTable12AddIfNonLiveEPKvPNS_10AllocValueEPNS_14AddNonLiveArgsE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::TakeSnapshot() -->
    <elf-symbol name='_ZN16HeapProfileTable12TakeSnapshotEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::WriteProfile(char const*, HeapProfileBucket const&, AddressMap<HeapProfileTable::AllocValue>*) -->
    <elf-symbol name='_ZN16HeapProfileTable12WriteProfileEPKcRK17HeapProfileBucketP10AddressMapINS_10AllocValueEE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::AddToSnapshot(void const*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*) -->
    <elf-symbol name='_ZN16HeapProfileTable13AddToSnapshotEPKvPNS_10AllocValueEPNS_8SnapshotE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::MarkAsIgnored(void const*) -->
    <elf-symbol name='_ZN16HeapProfileTable13MarkAsIgnoredEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::UnparseBucket(HeapProfileBucket const&, char*, int, int, char const*, HeapProfileStats*) -->
    <elf-symbol name='_ZN16HeapProfileTable13UnparseBucketERK17HeapProfileBucketPciiPKcP16HeapProfileStats' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::AllocValueSize(HeapProfileTable::AllocValue const&) -->
    <elf-symbol name='_ZN16HeapProfileTable14AllocValueSizeERKNS_10AllocValueE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::NonLiveSnapshot(HeapProfileTable::Snapshot*) -->
    <elf-symbol name='_ZN16HeapProfileTable15NonLiveSnapshotEPNS_8SnapshotE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::ReleaseSnapshot(HeapProfileTable::Snapshot*) -->
    <elf-symbol name='_ZN16HeapProfileTable15ReleaseSnapshotEPNS_8SnapshotE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::CleanupOldProfiles(char const*) -->
    <elf-symbol name='_ZN16HeapProfileTable18CleanupOldProfilesEPKc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::DumpBucketIterator(HeapProfileBucket const*, HeapProfileTable::BufferArgs*) -->
    <elf-symbol name='_ZN16HeapProfileTable18DumpBucketIteratorEPK17HeapProfileBucketPNS_10BufferArgsE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::DumpNonLiveIterator(void const*, HeapProfileTable::AllocValue*, HeapProfileTable::DumpArgs const&) -->
    <elf-symbol name='_ZN16HeapProfileTable19DumpNonLiveIteratorEPKvPNS_10AllocValueERKNS_8DumpArgsE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::GetCallerStackTrace(int, void**) -->
    <elf-symbol name='_ZN16HeapProfileTable19GetCallerStackTraceEiPPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::MapArgsAllocIterator(void const*, HeapProfileTable::AllocValue*, void (*)(void const*, HeapProfileTable::AllocInfo const&)) -->
    <elf-symbol name='_ZN16HeapProfileTable20MapArgsAllocIteratorEPKvPNS_10AllocValueEPFvS1_RKNS_9AllocInfoEE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::Snapshot::ReportLeaks(char const*, char const*, bool) -->
    <elf-symbol name='_ZN16HeapProfileTable8Snapshot11ReportLeaksEPKcS2_b' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::Snapshot::ReportObject(void const*, HeapProfileTable::AllocValue*, char*) -->
    <elf-symbol name='_ZN16HeapProfileTable8Snapshot12ReportObjectEPKvPNS_10AllocValueEPc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::Snapshot::ReportCallback(void const*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*) -->
    <elf-symbol name='_ZN16HeapProfileTable8Snapshot14ReportCallbackEPKvPNS_10AllocValueEPNS0_11ReportStateE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::Snapshot::ReportIndividualObjects() -->
    <elf-symbol name='_ZN16HeapProfileTable8Snapshot23ReportIndividualObjectsEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::GetBucket(int, void const* const*) -->
    <elf-symbol name='_ZN16HeapProfileTable9GetBucketEiPKPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::HeapProfileTable(void* (*)(unsigned long), void (*)(void*), bool) -->
    <elf-symbol name='_ZN16HeapProfileTableC1EPFPvmEPFvS0_Eb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::HeapProfileTable(void* (*)(unsigned long), void (*)(void*), bool) -->
    <elf-symbol name='_ZN16HeapProfileTableC2EPFPvmEPFvS0_Eb' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16HeapProfileTableC1EPFPvmEPFvS0_Eb' is-defined='yes'/>
    <!-- HeapProfileTable::~HeapProfileTable() -->
    <elf-symbol name='_ZN16HeapProfileTableD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16HeapProfileTableD2Ev' is-defined='yes'/>
    <!-- HeapProfileTable::~HeapProfileTable() -->
    <elf-symbol name='_ZN16HeapProfileTableD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MmapSysAllocator::Alloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN16MmapSysAllocator5AllocEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MmapSysAllocator::~MmapSysAllocator() -->
    <elf-symbol name='_ZN16MmapSysAllocatorD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MmapSysAllocator::~MmapSysAllocator() -->
    <elf-symbol name='_ZN16MmapSysAllocatorD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN16MmapSysAllocatorD2Ev' is-defined='yes'/>
    <!-- MmapSysAllocator::~MmapSysAllocator() -->
    <elf-symbol name='_ZN16MmapSysAllocatorD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::FormatLine(char*, int, unsigned long, unsigned long, char const*, unsigned long, long, char const*, unsigned long) -->
    <elf-symbol name='_ZN16ProcMapsIterator10FormatLineEPcimmPKcmlS2_m' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::Init(int, ProcMapsIterator::Buffer*, bool) -->
    <elf-symbol name='_ZN16ProcMapsIterator4InitEiPNS_6BufferEb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::Next(unsigned long*, unsigned long*, char**, unsigned long*, long*, char**) -->
    <elf-symbol name='_ZN16ProcMapsIterator4NextEPmS0_PPcS0_PlS2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::NextExt(unsigned long*, unsigned long*, char**, unsigned long*, long*, char**, unsigned long*, unsigned long*, unsigned long*, unsigned long*, unsigned long*) -->
    <elf-symbol name='_ZN16ProcMapsIterator7NextExtEPmS0_PPcS0_PlS2_S0_S0_S0_S0_S0_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC1Ei' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16ProcMapsIteratorC2Ei' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int, ProcMapsIterator::Buffer*) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC1EiPNS_6BufferE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int, ProcMapsIterator::Buffer*, bool) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC1EiPNS_6BufferEb' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16ProcMapsIteratorC2EiPNS_6BufferEb' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC2Ei' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int, ProcMapsIterator::Buffer*) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC2EiPNS_6BufferE' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16ProcMapsIteratorC1EiPNS_6BufferE' is-defined='yes'/>
    <!-- ProcMapsIterator::ProcMapsIterator(int, ProcMapsIterator::Buffer*, bool) -->
    <elf-symbol name='_ZN16ProcMapsIteratorC2EiPNS_6BufferEb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::~ProcMapsIterator() -->
    <elf-symbol name='_ZN16ProcMapsIteratorD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN16ProcMapsIteratorD2Ev' is-defined='yes'/>
    <!-- ProcMapsIterator::~ProcMapsIterator() -->
    <elf-symbol name='_ZN16ProcMapsIteratorD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SbrkSysAllocator::Alloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN16SbrkSysAllocator5AllocEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SbrkSysAllocator::~SbrkSysAllocator() -->
    <elf-symbol name='_ZN16SbrkSysAllocatorD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SbrkSysAllocator::~SbrkSysAllocator() -->
    <elf-symbol name='_ZN16SbrkSysAllocatorD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN16SbrkSysAllocatorD2Ev' is-defined='yes'/>
    <!-- SbrkSysAllocator::~SbrkSysAllocator() -->
    <elf-symbol name='_ZN16SbrkSysAllocatorD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMalloc_Printer::printf(char const*, ...) -->
    <elf-symbol name='_ZN16TCMalloc_Printer6printfEPKcz' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GoogleInitializer::~GoogleInitializer() -->
    <elf-symbol name='_ZN17GoogleInitializerD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- GoogleInitializer::~GoogleInitializer() -->
    <elf-symbol name='_ZN17GoogleInitializerD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN17GoogleInitializerD1Ev' is-defined='yes'/>
    <!-- DevMemSysAllocator::Alloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN18DevMemSysAllocator5AllocEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- DevMemSysAllocator::~DevMemSysAllocator() -->
    <elf-symbol name='_ZN18DevMemSysAllocatorD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- DevMemSysAllocator::~DevMemSysAllocator() -->
    <elf-symbol name='_ZN18DevMemSysAllocatorD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN18DevMemSysAllocatorD2Ev' is-defined='yes'/>
    <!-- DevMemSysAllocator::~DevMemSysAllocator() -->
    <elf-symbol name='_ZN18DevMemSysAllocatorD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- DefaultSysAllocator::Alloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN19DefaultSysAllocator5AllocEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- DefaultSysAllocator::~DefaultSysAllocator() -->
    <elf-symbol name='_ZN19DefaultSysAllocatorD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- DefaultSysAllocator::~DefaultSysAllocator() -->
    <elf-symbol name='_ZN19DefaultSysAllocatorD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN19DefaultSysAllocatorD2Ev' is-defined='yes'/>
    <!-- DefaultSysAllocator::~DefaultSysAllocator() -->
    <elf-symbol name='_ZN19DefaultSysAllocatorD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HugetlbSysAllocator::Initialize() -->
    <elf-symbol name='_ZN19HugetlbSysAllocator10InitializeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HugetlbSysAllocator::AllocInternal(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN19HugetlbSysAllocator13AllocInternalEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HugetlbSysAllocator::Alloc(unsigned long, unsigned long*, unsigned long) -->
    <elf-symbol name='_ZN19HugetlbSysAllocator5AllocEmPmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HugetlbSysAllocator::~HugetlbSysAllocator() -->
    <elf-symbol name='_ZN19HugetlbSysAllocatorD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HugetlbSysAllocator::~HugetlbSysAllocator() -->
    <elf-symbol name='_ZN19HugetlbSysAllocatorD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN19HugetlbSysAllocatorD2Ev' is-defined='yes'/>
    <!-- HugetlbSysAllocator::~HugetlbSysAllocator() -->
    <elf-symbol name='_ZN19HugetlbSysAllocatorD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileEndWriter::~HeapProfileEndWriter() -->
    <elf-symbol name='_ZN20HeapProfileEndWriterD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN20HeapProfileEndWriterD2Ev' is-defined='yes'/>
    <!-- HeapProfileEndWriter::~HeapProfileEndWriter() -->
    <elf-symbol name='_ZN20HeapProfileEndWriterD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetOwnership(void const*) -->
    <elf-symbol name='_ZN22TCMallocImplementation12GetOwnershipEPKv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetHeapSample(std::string*) -->
    <elf-symbol name='_ZN22TCMallocImplementation13GetHeapSampleEPSs' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::MarkThreadBusy() -->
    <elf-symbol name='_ZN22TCMallocImplementation14MarkThreadBusyEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::MarkThreadIdle() -->
    <elf-symbol name='_ZN22TCMallocImplementation14MarkThreadIdleEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::ReadStackTraces(int*) -->
    <elf-symbol name='_ZN22TCMallocImplementation15ReadStackTracesEPi' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::ReleaseToSystem(unsigned long) -->
    <elf-symbol name='_ZN22TCMallocImplementation15ReleaseToSystemEm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetAllocatedSize(void const*) -->
    <elf-symbol name='_ZN22TCMallocImplementation16GetAllocatedSizeEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*) -->
    <elf-symbol name='_ZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetNumericProperty(char const*, unsigned long*) -->
    <elf-symbol name='_ZN22TCMallocImplementation18GetNumericPropertyEPKcPm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetSystemAllocator() -->
    <elf-symbol name='_ZN22TCMallocImplementation18GetSystemAllocatorEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::SetNumericProperty(char const*, unsigned long) -->
    <elf-symbol name='_ZN22TCMallocImplementation18SetNumericPropertyEPKcm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::SetSystemAllocator(SysAllocator*) -->
    <elf-symbol name='_ZN22TCMallocImplementation18SetSystemAllocatorEP12SysAllocator' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetMemoryReleaseRate() -->
    <elf-symbol name='_ZN22TCMallocImplementation20GetMemoryReleaseRateEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::SetMemoryReleaseRate(double) -->
    <elf-symbol name='_ZN22TCMallocImplementation20SetMemoryReleaseRateEd' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetEstimatedAllocatedSize(unsigned long) -->
    <elf-symbol name='_ZN22TCMallocImplementation25GetEstimatedAllocatedSizeEm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::ReadHeapGrowthStackTraces() -->
    <elf-symbol name='_ZN22TCMallocImplementation25ReadHeapGrowthStackTracesEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::Ranges(void*, void (*)(void*, base::MallocRange const*)) -->
    <elf-symbol name='_ZN22TCMallocImplementation6RangesEPvPFvS0_PKN4base11MallocRangeEE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetStats(char*, int) -->
    <elf-symbol name='_ZN22TCMallocImplementation8GetStatsEPci' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::~TCMallocImplementation() -->
    <elf-symbol name='_ZN22TCMallocImplementationD0Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::~TCMallocImplementation() -->
    <elf-symbol name='_ZN22TCMallocImplementationD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN22TCMallocImplementationD2Ev' is-defined='yes'/>
    <!-- TCMallocImplementation::~TCMallocImplementation() -->
    <elf-symbol name='_ZN22TCMallocImplementationD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakCheckerGlobalPrePost::~HeapLeakCheckerGlobalPrePost() -->
    <elf-symbol name='_ZN28HeapLeakCheckerGlobalPrePostD1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZN28HeapLeakCheckerGlobalPrePostD2Ev' is-defined='yes'/>
    <!-- HeapLeakCheckerGlobalPrePost::~HeapLeakCheckerGlobalPrePost() -->
    <elf-symbol name='_ZN28HeapLeakCheckerGlobalPrePostD2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::RawPrinter::Printf(char const*, ...) -->
    <elf-symbol name='_ZN4base10RawPrinter6PrintfEPKcz' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::RawPrinter::RawPrinter(char*, int) -->
    <elf-symbol name='_ZN4base10RawPrinterC1EPci' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN4base10RawPrinterC2EPci' is-defined='yes'/>
    <!-- base::RawPrinter::RawPrinter(char*, int) -->
    <elf-symbol name='_ZN4base10RawPrinterC2EPci' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::Update(int) -->
    <elf-symbol name='_ZN4base11ElfMemImage14SymbolIterator6UpdateEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::SymbolIterator(void const*, int) -->
    <elf-symbol name='_ZN4base11ElfMemImage14SymbolIteratorC1EPKvi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::SymbolIterator(void const*, int) -->
    <elf-symbol name='_ZN4base11ElfMemImage14SymbolIteratorC2EPKvi' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN4base11ElfMemImage14SymbolIteratorC1EPKvi' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::operator++() -->
    <elf-symbol name='_ZN4base11ElfMemImage14SymbolIteratorppEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::Init(void const*) -->
    <elf-symbol name='_ZN4base11ElfMemImage4InitEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::ElfMemImage(void const*) -->
    <elf-symbol name='_ZN4base11ElfMemImageC1EPKv' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN4base11ElfMemImageC2EPKv' is-defined='yes'/>
    <!-- base::ElfMemImage::ElfMemImage(void const*) -->
    <elf-symbol name='_ZN4base11ElfMemImageC2EPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::Init() -->
    <elf-symbol name='_ZN4base11VDSOSupport4InitEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::SetBase(void const*) -->
    <elf-symbol name='_ZN4base11VDSOSupport7SetBaseEPKv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::VDSOSupport() -->
    <elf-symbol name='_ZN4base11VDSOSupportC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN4base11VDSOSupportC2Ev' is-defined='yes'/>
    <!-- base::VDSOSupport::VDSOSupport() -->
    <elf-symbol name='_ZN4base11VDSOSupportC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::SubmitSpinLockProfileData(void const*, long) -->
    <elf-symbol name='_ZN4base25SubmitSpinLockProfileDataEPKvl' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::SpinLockWait(int volatile*, int, base::internal::SpinLockWaitTransition const*) -->
    <elf-symbol name='_ZN4base8internal12SpinLockWaitEPViiPKNS0_22SpinLockWaitTransitionE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::SpinLockWake(int volatile*, bool) -->
    <elf-symbol name='_ZN4base8internal12SpinLockWakeEPVib' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::SpinLockDelay(int volatile*, int, int) -->
    <elf-symbol name='_ZN4base8internal13SpinLockDelayEPViii' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::ExchangeSingular(void (*)(void const*, unsigned long)) -->
    <elf-symbol name='_ZN4base8internal8HookListIPFvPKvmEE16ExchangeSingularES5_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::FixupPrivEndLocked() -->
    <elf-symbol name='_ZN4base8internal8HookListIPFvPKvmEE18FixupPrivEndLockedEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::Add(void (*)(void const*, unsigned long)) -->
    <elf-symbol name='_ZN4base8internal8HookListIPFvPKvmEE3AddES5_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::Remove(void (*)(void const*, unsigned long)) -->
    <elf-symbol name='_ZN4base8internal8HookListIPFvPKvmEE6RemoveES5_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLock::SlowUnlock(unsigned long) -->
    <elf-symbol name='_ZN8SpinLock10SlowUnlockEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLock::SlowLock() -->
    <elf-symbol name='_ZN8SpinLock8SlowLockEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLock::SpinLoop(long, int*) -->
    <elf-symbol name='_ZN8SpinLock8SpinLoopElPi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DLL_Length(tcmalloc::Span const*) -->
    <elf-symbol name='_ZN8tcmalloc10DLL_LengthEPKNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DLL_Remove(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc10DLL_RemoveEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DeleteSpan(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc10DeleteSpanEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DLL_Prepend(tcmalloc::Span*, tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc11DLL_PrependEPNS_4SpanES1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::BecomeIdle() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache10BecomeIdleEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::InitModule() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache10InitModuleEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::DeleteCache(tcmalloc::ThreadCache*) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache11DeleteCacheEPS0_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::ListTooLong(tcmalloc::ThreadCache::FreeList*, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache11ListTooLongEPNS0_8FreeListEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::GetThreadStats(unsigned long*, unsigned long*) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache14GetThreadStatsEPmS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::GetSamplePeriod() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache15GetSamplePeriodEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::DestroyThreadCache(void*) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache18DestroyThreadCacheEPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::IncreaseCacheLimit() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache18IncreaseCacheLimitEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::FetchFromCentralCache(unsigned long, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache21FetchFromCentralCacheEmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::ReleaseToCentralCache(tcmalloc::ThreadCache::FreeList*, unsigned long, int) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache21ReleaseToCentralCacheEPNS0_8FreeListEmi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::CreateCacheIfNecessary() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache22CreateCacheIfNecessaryEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::IncreaseCacheLimitLocked() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache24IncreaseCacheLimitLockedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::RecomputePerThreadCacheSize() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache27RecomputePerThreadCacheSizeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::set_overall_thread_cache_size(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache29set_overall_thread_cache_sizeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::Init(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache4InitEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::Cleanup() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache7CleanupEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::InitTSD() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache7InitTSDEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::NewHeap(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache7NewHeapEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::GetCache() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache8GetCacheEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::Scavenge() -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache8ScavengeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::MetaDataAlloc(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc13MetaDataAllocEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::InsertRange(void*, void*, int) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList11InsertRangeEPvS1_i' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::RemoveRange(void**, void**, int) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList11RemoveRangeEPPvS2_i' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::ShrinkCache(int, bool) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList11ShrinkCacheEib' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::OverheadBytes() -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList13OverheadBytesEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::MakeCacheSpace() -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList14MakeCacheSpaceEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::ReleaseToSpans(void*) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList14ReleaseToSpansEPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::FetchFromOneSpans(int, void**, void**) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList17FetchFromOneSpansEiPPvS2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::ReleaseListToSpans(void*) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList18ReleaseListToSpansEPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::EvictRandomSizeClass(int, bool) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList20EvictRandomSizeClassEib' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::FetchFromOneSpansSafe(int, void**, void**) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList21FetchFromOneSpansSafeEiPPvS2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::Init(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList4InitEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::Populate() -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList8PopulateEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::CentralFreeList::tc_length() -->
    <elf-symbol name='_ZN8tcmalloc15CentralFreeList9tc_lengthEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::ReadStackTracesAndClear() -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTable23ReadStackTracesAndClearEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::AddTrace(tcmalloc::StackTrace const&) -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTable8AddTraceERKNS_10StackTraceE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::StackTraceTable() -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTableC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::StackTraceTable() -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTableC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN8tcmalloc15StackTraceTableC1Ev' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::~StackTraceTable() -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTableD1Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::~StackTraceTable() -->
    <elf-symbol name='_ZN8tcmalloc15StackTraceTableD2Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN8tcmalloc15StackTraceTableD1Ev' is-defined='yes'/>
    <!-- tcmalloc::AlignmentForSize(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc16AlignmentForSizeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DumpProcSelfMaps(int) -->
    <elf-symbol name='_ZN8tcmalloc16DumpProcSelfMapsEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::FillProcSelfMaps(char*, int, bool*) -->
    <elf-symbol name='_ZN8tcmalloc16FillProcSelfMapsEPciPb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::commandlineflags::StringToBool(char const*, bool) -->
    <elf-symbol name='_ZN8tcmalloc16commandlineflags12StringToBoolEPKcb' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::metadata_system_bytes() -->
    <elf-symbol name='_ZN8tcmalloc21metadata_system_bytesEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Log(tcmalloc::LogMode, char const*, int, tcmalloc::LogItem, tcmalloc::LogItem, tcmalloc::LogItem, tcmalloc::LogItem) -->
    <elf-symbol name='_ZN8tcmalloc3LogENS_7LogModeEPKciNS_7LogItemES3_S3_S3_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Logger::Add(tcmalloc::LogItem const&) -->
    <elf-symbol name='_ZN8tcmalloc6Logger3AddERKNS_7LogItemE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Logger::AddNum(unsigned long, int) -->
    <elf-symbol name='_ZN8tcmalloc6Logger6AddNumEmi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Logger::AddStr(char const*, int) -->
    <elf-symbol name='_ZN8tcmalloc6Logger6AddStrEPKci' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::InitStaticVars() -->
    <elf-symbol name='_ZN8tcmalloc6Static14InitStaticVarsEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::NewSpan(unsigned long, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc7NewSpanEmm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::InitStatics() -->
    <elf-symbol name='_ZN8tcmalloc7Sampler11InitStaticsEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::GetSamplePeriod() -->
    <elf-symbol name='_ZN8tcmalloc7Sampler15GetSamplePeriodEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::PickNextSamplingPoint() -->
    <elf-symbol name='_ZN8tcmalloc7Sampler21PickNextSamplingPointEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::PopulateFastLog2Table() -->
    <elf-symbol name='_ZN8tcmalloc7Sampler21PopulateFastLog2TableEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::Init(unsigned int) -->
    <elf-symbol name='_ZN8tcmalloc7Sampler4InitEj' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::SizeMap::NumMoveSize(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc7SizeMap11NumMoveSizeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::SizeMap::Init() -->
    <elf-symbol name='_ZN8tcmalloc7SizeMap4InitEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::DLL_Init(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8DLL_InitEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::AllocLarge(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap10AllocLargeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::CommitSpan(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap10CommitSpanEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::EnsureLimit(unsigned long, bool) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap11EnsureLimitEmb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::DecommitSpan(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap12DecommitSpanEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::GetNextRange(unsigned long, base::MallocRange*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap12GetNextRangeEmPN4base11MallocRangeE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::MayMergeSpans(tcmalloc::Span*, tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap13MayMergeSpansEPNS_4SpanES2_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::CheckExpensive() -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap14CheckExpensiveEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::GetLargeSpanStats(tcmalloc::PageHeap::LargeSpanStats*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap17GetLargeSpanStatsEPNS0_14LargeSpanStatsE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::GetSmallSpanStats(tcmalloc::PageHeap::SmallSpanStats*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap17GetSmallSpanStatsEPNS0_14SmallSpanStatsE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::MergeIntoFreeList(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap17MergeIntoFreeListEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::PrependToFreeList(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap17PrependToFreeListEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::RegisterSizeClass(tcmalloc::Span*, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap17RegisterSizeClassEPNS_4SpanEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::RemoveFromFreeList(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap18RemoveFromFreeListEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::IncrementalScavenge(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap19IncrementalScavengeEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::ReleaseAtLeastNPages(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap20ReleaseAtLeastNPagesEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::ReleaseLastNormalSpan(tcmalloc::PageHeap::SpanList*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap21ReleaseLastNormalSpanEPNS0_8SpanListE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::SearchFreeAndLargeLists(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap23SearchFreeAndLargeListsEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::New(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap3NewEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::Carve(tcmalloc::Span*, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap5CarveEPNS_4SpanEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::Check() -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap5CheckEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::Split(tcmalloc::Span*, unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap5SplitEPNS_4SpanEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::Delete(tcmalloc::Span*) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap6DeleteEPNS_4SpanE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::GrowHeap(unsigned long) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap8GrowHeapEm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::CheckList(tcmalloc::Span*, unsigned long, unsigned long, int) -->
    <elf-symbol name='_ZN8tcmalloc8PageHeap9CheckListEPNS_4SpanEmmi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::PageHeap() -->
    <elf-symbol name='_ZN8tcmalloc8PageHeapC1Ev' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZN8tcmalloc8PageHeapC2Ev' is-defined='yes'/>
    <!-- tcmalloc::PageHeap::PageHeap() -->
    <elf-symbol name='_ZN8tcmalloc8PageHeapC2Ev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::GetCurrentState(ProfileData::State*) const -->
    <elf-symbol name='_ZNK11ProfileData15GetCurrentStateEPNS_5StateE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::BytesLeaked() const -->
    <elf-symbol name='_ZNK15HeapLeakChecker11BytesLeakedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::ObjectsLeaked() const -->
    <elf-symbol name='_ZNK15HeapLeakChecker13ObjectsLeakedEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::FindInsideAlloc(void const*, unsigned long, void const**, unsigned long*) const -->
    <elf-symbol name='_ZNK16HeapProfileTable15FindInsideAllocEPKvmPS1_Pm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::FindAllocDetails(void const*, HeapProfileTable::AllocInfo*) const -->
    <elf-symbol name='_ZNK16HeapProfileTable16FindAllocDetailsEPKvPNS_9AllocInfoE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::FillOrderedProfile(char*, int) const -->
    <elf-symbol name='_ZNK16HeapProfileTable18FillOrderedProfileEPci' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::MakeSortedBucketList() const -->
    <elf-symbol name='_ZNK16HeapProfileTable20MakeSortedBucketListEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::IterateOrderedAllocContexts(void (*)(HeapProfileTable::AllocContextInfo const&)) const -->
    <elf-symbol name='_ZNK16HeapProfileTable27IterateOrderedAllocContextsEPFvRKNS_16AllocContextInfoEE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::FindAlloc(void const*, unsigned long*) const -->
    <elf-symbol name='_ZNK16HeapProfileTable9FindAllocEPKvPm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProcMapsIterator::Valid() const -->
    <elf-symbol name='_ZNK16ProcMapsIterator5ValidEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetSymAddr(Elf64_Sym const*) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage10GetSymAddrEPK9Elf64_Sym' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetVerdefAux(Elf64_Verdef const*) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage12GetVerdefAuxEPK12Elf64_Verdef' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::LookupSymbol(char const*, char const*, int, base::ElfMemImage::SymbolInfo*) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage12LookupSymbolEPKcS2_iPNS0_10SymbolInfoE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetNumSymbols() const -->
    <elf-symbol name='_ZNK4base11ElfMemImage13GetNumSymbolsEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::operator*() const -->
    <elf-symbol name='_ZNK4base11ElfMemImage14SymbolIteratordeEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::operator==(base::ElfMemImage::SymbolIterator const&) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage14SymbolIteratoreqERKS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::operator!=(base::ElfMemImage::SymbolIterator const&) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage14SymbolIteratorneERKS1_' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::SymbolIterator::operator&#45;>() const -->
    <elf-symbol name='_ZNK4base11ElfMemImage14SymbolIteratorptEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::LookupSymbolByAddress(void const*, base::ElfMemImage::SymbolInfo*) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage21LookupSymbolByAddressEPKvPNS0_10SymbolInfoE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::end() const -->
    <elf-symbol name='_ZNK4base11ElfMemImage3endEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::begin() const -->
    <elf-symbol name='_ZNK4base11ElfMemImage5beginEv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetPhdr(int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage7GetPhdrEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetDynstr(unsigned int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage9GetDynstrEj' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetDynsym(int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage9GetDynsymEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetVerdef(int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage9GetVerdefEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetVerstr(unsigned int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage9GetVerstrEj' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::GetVersym(int) const -->
    <elf-symbol name='_ZNK4base11ElfMemImage9GetVersymEi' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::LookupSymbol(char const*, char const*, int, base::ElfMemImage::SymbolInfo*) const -->
    <elf-symbol name='_ZNK4base11VDSOSupport12LookupSymbolEPKcS2_iPNS_11ElfMemImage10SymbolInfoE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::LookupSymbolByAddress(void const*, base::ElfMemImage::SymbolInfo*) const -->
    <elf-symbol name='_ZNK4base11VDSOSupport21LookupSymbolByAddressEPKvPNS_11ElfMemImage10SymbolInfoE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::GetSingular() const -->
    <elf-symbol name='_ZNK4base8internal8HookListIPFvPKvmEE11GetSingularEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::empty() const -->
    <elf-symbol name='_ZNK4base8internal8HookListIPFvPKvmEE5emptyEv' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::internal::HookList<void (*)(void const*, unsigned long)>::Traverse(void (**)(void const*, unsigned long), int) const -->
    <elf-symbol name='_ZNK4base8internal8HookListIPFvPKvmEE8TraverseEPS5_i' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::StackTraceTable::Bucket::KeyEqual(unsigned long, tcmalloc::StackTrace const&) const -->
    <elf-symbol name='_ZNK8tcmalloc15StackTraceTable6Bucket8KeyEqualEmRKNS_10StackTraceE' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_destroy(STL_Allocator<char, HeapLeakChecker::Allocator> const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_destroyERKS4_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_create(unsigned long, unsigned long, STL_Allocator<char, HeapLeakChecker::Allocator> const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep9_S_createEmmRKS4_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(char const*, STL_Allocator<char, HeapLeakChecker::Allocator> const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC1EPKcRKS4_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC1ERKS5_' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC2ERKS5_' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(char const*, STL_Allocator<char, HeapLeakChecker::Allocator> const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC2EPKcRKS4_' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC1EPKcRKS4_' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const&) -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC2ERKS5_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::~basic_string() -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEED1Ev' type='func-type' binding='weak-binding' visibility='default-visibility' alias='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEED2Ev' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::~basic_string() -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEED2Ev' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_insert_aux(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, AllocObject const&) -->
    <elf-symbol name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_insert_aux(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, MallocExtension::FreeListInfo const&) -->
    <elf-symbol name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::vector<void (*)(), std::allocator<void (*)()> >::_M_insert_aux(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, void (* const&)()) -->
    <elf-symbol name='_ZNSt6vectorIPFvvESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_insert_aux(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, void* const&) -->
    <elf-symbol name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, MemoryRegionMap::Region const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKS1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_erase(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
    <elf-symbol name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS1_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<HeapProfileBucket*, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileBucket*>, std::allocator<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_M_insert_EPKSt18_Rb_tree_node_baseSG_RKS7_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<HeapProfileBucket*, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileBucket*>, std::allocator<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique(std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_uniqueERKS7_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<HeapProfileBucket*, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileBucket*>, std::allocator<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS7_ERKS7_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<HeapProfileBucket*, std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileBucket*>, std::allocator<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_erase(std::_Rb_tree_node<std::pair<HeapProfileBucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
    <elf-symbol name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_eraseEPSt13_Rb_tree_nodeIS7_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<void const*, std::pair<void const* const, char const*>, std::_Select1st<std::pair<void const* const, char const*> >, std::less<void const*>, std::allocator<std::pair<void const* const, char const*> > >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, std::pair<void const* const, char const*> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS6_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<void const*, std::pair<void const* const, char const*>, std::_Select1st<std::pair<void const* const, char const*> >, std::less<void const*>, std::allocator<std::pair<void const* const, char const*> > >::_M_insert_unique(std::pair<void const* const, char const*> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE16_M_insert_uniqueERKS6_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<void const*, std::pair<void const* const, char const*>, std::_Select1st<std::pair<void const* const, char const*> >, std::less<void const*>, std::allocator<std::pair<void const* const, char const*> > >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<void const* const, char const*> >, std::pair<void const* const, char const*> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS6_ERKS6_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<void const*, std::pair<void const* const, char const*>, std::_Select1st<std::pair<void const* const, char const*> >, std::less<void const*>, std::allocator<std::pair<void const* const, char const*> > >::_M_erase(std::_Rb_tree_node<std::pair<void const* const, char const*> >*) -->
    <elf-symbol name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_M_eraseEPSt13_Rb_tree_nodeIS6_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_M_insert_EPKSt18_Rb_tree_node_baseSM_RKSD_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_unique(std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE16_M_insert_uniqueERKSD_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorISD_ERKSD_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > const, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
    <elf-symbol name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_M_eraseEPSt13_Rb_tree_nodeISD_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, std::pair<unsigned long const, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<unsigned long const, HeapLeakChecker::RangeValue> >, std::less<unsigned long>, STL_Allocator<std::pair<unsigned long const, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, std::pair<unsigned long const, HeapLeakChecker::RangeValue> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS4_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, std::pair<unsigned long const, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<unsigned long const, HeapLeakChecker::RangeValue> >, std::less<unsigned long>, STL_Allocator<std::pair<unsigned long const, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<unsigned long const, HeapLeakChecker::RangeValue> >*) -->
    <elf-symbol name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS4_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, std::pair<unsigned long const, unsigned long>, std::_Select1st<std::pair<unsigned long const, unsigned long> >, std::less<unsigned long>, STL_Allocator<std::pair<unsigned long const, unsigned long>, HeapLeakChecker::Allocator> >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, std::pair<unsigned long const, unsigned long> const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSE_RKS2_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, std::pair<unsigned long const, unsigned long>, std::_Select1st<std::pair<unsigned long const, unsigned long> >, std::less<unsigned long>, STL_Allocator<std::pair<unsigned long const, unsigned long>, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<unsigned long const, unsigned long> >*) -->
    <elf-symbol name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS2_E' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, unsigned long, std::_Identity<unsigned long>, std::less<unsigned long>, STL_Allocator<unsigned long, HeapLeakChecker::Allocator> >::_M_insert_(std::_Rb_tree_node_base const*, std::_Rb_tree_node_base const*, unsigned long const&) -->
    <elf-symbol name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKm' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::_Rb_tree<unsigned long, unsigned long, std::_Identity<unsigned long>, std::less<unsigned long>, STL_Allocator<unsigned long, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<unsigned long>*) -->
    <elf-symbol name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeImE' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__adjust_heap<HeapProfileTable::Snapshot::Entry*, long, HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry*, long, long, HeapProfileTable::Snapshot::Entry) -->
    <elf-symbol name='_ZSt13__adjust_heapIPN16HeapProfileTable8Snapshot5EntryElS2_EvT_T0_S5_T1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__adjust_heap<HeapProfileBucket**, long, HeapProfileBucket*, bool (*)(HeapProfileStats*, HeapProfileStats*)>(HeapProfileBucket**, long, long, HeapProfileBucket*, bool (*)(HeapProfileStats*, HeapProfileStats*)) -->
    <elf-symbol name='_ZSt13__adjust_heapIPP17HeapProfileBucketlS1_PFbP16HeapProfileStatsS4_EEvT_T0_S8_T1_T2_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__heap_select<HeapProfileBucket**, bool (*)(HeapProfileStats*, HeapProfileStats*)>(HeapProfileBucket**, HeapProfileBucket**, HeapProfileBucket**, bool (*)(HeapProfileStats*, HeapProfileStats*)) -->
    <elf-symbol name='_ZSt13__heap_selectIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_S7_T0_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__insertion_sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
    <elf-symbol name='_ZSt16__insertion_sortIPN16HeapProfileTable8Snapshot5EntryEEvT_S4_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__insertion_sort<HeapProfileBucket**, bool (*)(HeapProfileStats*, HeapProfileStats*)>(HeapProfileBucket**, HeapProfileBucket**, bool (*)(HeapProfileStats*, HeapProfileStats*)) -->
    <elf-symbol name='_ZSt16__insertion_sortIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_T0_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__introsort_loop<HeapProfileTable::Snapshot::Entry*, long>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, long) -->
    <elf-symbol name='_ZSt16__introsort_loopIPN16HeapProfileTable8Snapshot5EntryElEvT_S4_T0_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- void std::__introsort_loop<HeapProfileBucket**, long, bool (*)(HeapProfileStats*, HeapProfileStats*)>(HeapProfileBucket**, HeapProfileBucket**, long, bool (*)(HeapProfileStats*, HeapProfileStats*)) -->
    <elf-symbol name='_ZSt16__introsort_loopIPP17HeapProfileBucketlPFbP16HeapProfileStatsS4_EEvT_S7_T0_T1_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, char const*) -->
    <elf-symbol name='_ZStplIcSt11char_traitsIcESaIcEESbIT_T0_T1_ERKS6_PKS3_' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator delete[](void*) -->
    <elf-symbol name='_ZdaPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator delete[](void*, std::nothrow_t const&) -->
    <elf-symbol name='_ZdaPvRKSt9nothrow_t' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator delete(void*) -->
    <elf-symbol name='_ZdlPv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator delete(void*, std::nothrow_t const&) -->
    <elf-symbol name='_ZdlPvRKSt9nothrow_t' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator new[](unsigned long) -->
    <elf-symbol name='_Znam' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator new[](unsigned long, std::nothrow_t const&) -->
    <elf-symbol name='_ZnamRKSt9nothrow_t' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator new(unsigned long) -->
    <elf-symbol name='_Znwm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- operator new(unsigned long, std::nothrow_t const&) -->
    <elf-symbol name='_ZnwmRKSt9nothrow_t' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_calloc -->
    <elf-symbol name='__libc_calloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_cfree -->
    <elf-symbol name='__libc_cfree' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_free -->
    <elf-symbol name='__libc_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_malloc -->
    <elf-symbol name='__libc_malloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_memalign -->
    <elf-symbol name='__libc_memalign' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_pvalloc -->
    <elf-symbol name='__libc_pvalloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_realloc -->
    <elf-symbol name='__libc_realloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __libc_valloc -->
    <elf-symbol name='__libc_valloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __posix_memalign -->
    <elf-symbol name='__posix_memalign' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- _fini -->
    <elf-symbol name='_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- _init -->
    <elf-symbol name='_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- calloc -->
    <elf-symbol name='calloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- cfree -->
    <elf-symbol name='cfree' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- free -->
    <elf-symbol name='free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- mallinfo -->
    <elf-symbol name='mallinfo' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- malloc -->
    <elf-symbol name='malloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- malloc_size -->
    <elf-symbol name='malloc_size' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- malloc_stats -->
    <elf-symbol name='malloc_stats' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- malloc_usable_size -->
    <elf-symbol name='malloc_usable_size' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- mallopt -->
    <elf-symbol name='mallopt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- memalign -->
    <elf-symbol name='memalign' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- mmap -->
    <elf-symbol name='mmap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- mmap64 -->
    <elf-symbol name='mmap64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- mremap -->
    <elf-symbol name='mremap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- munmap -->
    <elf-symbol name='munmap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- posix_memalign -->
    <elf-symbol name='posix_memalign' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- pvalloc -->
    <elf-symbol name='pvalloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- realloc -->
    <elf-symbol name='realloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- sbrk -->
    <elf-symbol name='sbrk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tc_calloc -->
    <elf-symbol name='tc_calloc' type='func-type' binding='global-binding' visibility='default-visibility' alias='calloc,__libc_calloc' is-defined='yes'/>
    <!-- tc_cfree -->
    <elf-symbol name='tc_cfree' type='func-type' binding='global-binding' visibility='default-visibility' alias='__libc_cfree,cfree' is-defined='yes'/>
    <!-- tc_delete -->
    <elf-symbol name='tc_delete' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZdlPv' is-defined='yes'/>
    <!-- tc_delete_nothrow -->
    <elf-symbol name='tc_delete_nothrow' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZdlPvRKSt9nothrow_t' is-defined='yes'/>
    <!-- tc_deletearray -->
    <elf-symbol name='tc_deletearray' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZdaPv' is-defined='yes'/>
    <!-- tc_deletearray_nothrow -->
    <elf-symbol name='tc_deletearray_nothrow' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZdaPvRKSt9nothrow_t' is-defined='yes'/>
    <!-- tc_free -->
    <elf-symbol name='tc_free' type='func-type' binding='global-binding' visibility='default-visibility' alias='free,__libc_free' is-defined='yes'/>
    <!-- tc_mallinfo -->
    <elf-symbol name='tc_mallinfo' type='func-type' binding='global-binding' visibility='default-visibility' alias='mallinfo' is-defined='yes'/>
    <!-- tc_malloc -->
    <elf-symbol name='tc_malloc' type='func-type' binding='global-binding' visibility='default-visibility' alias='__libc_malloc,malloc' is-defined='yes'/>
    <!-- tc_malloc_size -->
    <elf-symbol name='tc_malloc_size' type='func-type' binding='global-binding' visibility='default-visibility' alias='malloc_usable_size,malloc_size' is-defined='yes'/>
    <!-- tc_malloc_skip_new_handler -->
    <elf-symbol name='tc_malloc_skip_new_handler' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tc_malloc_stats -->
    <elf-symbol name='tc_malloc_stats' type='func-type' binding='global-binding' visibility='default-visibility' alias='malloc_stats' is-defined='yes'/>
    <!-- tc_mallopt -->
    <elf-symbol name='tc_mallopt' type='func-type' binding='global-binding' visibility='default-visibility' alias='mallopt' is-defined='yes'/>
    <!-- tc_memalign -->
    <elf-symbol name='tc_memalign' type='func-type' binding='global-binding' visibility='default-visibility' alias='memalign,__libc_memalign' is-defined='yes'/>
    <!-- tc_new -->
    <elf-symbol name='tc_new' type='func-type' binding='global-binding' visibility='default-visibility' alias='_Znwm' is-defined='yes'/>
    <!-- tc_new_nothrow -->
    <elf-symbol name='tc_new_nothrow' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZnwmRKSt9nothrow_t' is-defined='yes'/>
    <!-- tc_newarray -->
    <elf-symbol name='tc_newarray' type='func-type' binding='global-binding' visibility='default-visibility' alias='_Znam' is-defined='yes'/>
    <!-- tc_newarray_nothrow -->
    <elf-symbol name='tc_newarray_nothrow' type='func-type' binding='global-binding' visibility='default-visibility' alias='_ZnamRKSt9nothrow_t' is-defined='yes'/>
    <!-- tc_posix_memalign -->
    <elf-symbol name='tc_posix_memalign' type='func-type' binding='global-binding' visibility='default-visibility' alias='__posix_memalign,posix_memalign' is-defined='yes'/>
    <!-- tc_pvalloc -->
    <elf-symbol name='tc_pvalloc' type='func-type' binding='global-binding' visibility='default-visibility' alias='pvalloc,__libc_pvalloc' is-defined='yes'/>
    <!-- tc_realloc -->
    <elf-symbol name='tc_realloc' type='func-type' binding='global-binding' visibility='default-visibility' alias='__libc_realloc,realloc' is-defined='yes'/>
    <!-- tc_set_new_mode -->
    <elf-symbol name='tc_set_new_mode' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tc_valloc -->
    <elf-symbol name='tc_valloc' type='func-type' binding='global-binding' visibility='default-visibility' alias='__libc_valloc,valloc' is-defined='yes'/>
    <!-- tc_version -->
    <elf-symbol name='tc_version' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- valloc -->
    <elf-symbol name='valloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
  </elf-function-symbols>
  <elf-variable-symbols>
    <!-- TCMalloc_SystemTaken -->
    <elf-symbol name='TCMalloc_SystemTaken' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- CpuProfiler::instance_ -->
    <elf-symbol name='_ZN11CpuProfiler9instance_E' size='88' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapCleaner::heap_cleanups_ -->
    <elf-symbol name='_ZN11HeapCleaner14heap_cleanups_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::kBufferLength -->
    <elf-symbol name='_ZN11ProfileData13kBufferLengthE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::kAssociativity -->
    <elf-symbol name='_ZN11ProfileData14kAssociativityE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::kMaxStackDepth -->
    <elf-symbol name='_ZN11ProfileData14kMaxStackDepthE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileData::kBuckets -->
    <elf-symbol name='_ZN11ProfileData8kBucketsE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::kMaxFrequency -->
    <elf-symbol name='_ZN14ProfileHandler13kMaxFrequencyE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::kDefaultFrequency -->
    <elf-symbol name='_ZN14ProfileHandler17kDefaultFrequencyE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::once_ -->
    <elf-symbol name='_ZN14ProfileHandler5once_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- ProfileHandler::instance_ -->
    <elf-symbol name='_ZN14ProfileHandler9instance_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Allocator::alloc_count_ -->
    <elf-symbol name='_ZN15HeapLeakChecker9Allocator12alloc_count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakChecker::Allocator::arena_ -->
    <elf-symbol name='_ZN15HeapLeakChecker9Allocator6arena_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::owner_lock_ -->
    <elf-symbol name='_ZN15MemoryRegionMap11owner_lock_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::unmap_size_ -->
    <elf-symbol name='_ZN15MemoryRegionMap11unmap_size_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::num_buckets_ -->
    <elf-symbol name='_ZN15MemoryRegionMap12num_buckets_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::bucket_table_ -->
    <elf-symbol name='_ZN15MemoryRegionMap13bucket_table_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::client_count_ -->
    <elf-symbol name='_ZN15MemoryRegionMap13client_count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::saved_buckets_ -->
    <elf-symbol name='_ZN15MemoryRegionMap14saved_buckets_E' size='1120' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::lock_owner_tid_ -->
    <elf-symbol name='_ZN15MemoryRegionMap15lock_owner_tid_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::max_stack_depth_ -->
    <elf-symbol name='_ZN15MemoryRegionMap16max_stack_depth_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::recursion_count_ -->
    <elf-symbol name='_ZN15MemoryRegionMap16recursion_count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::saved_buckets_keys_ -->
    <elf-symbol name='_ZN15MemoryRegionMap19saved_buckets_keys_E' size='5120' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::saved_buckets_count_ -->
    <elf-symbol name='_ZN15MemoryRegionMap20saved_buckets_count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::lock_ -->
    <elf-symbol name='_ZN15MemoryRegionMap5lock_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::arena_ -->
    <elf-symbol name='_ZN15MemoryRegionMap6arena_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::regions_ -->
    <elf-symbol name='_ZN15MemoryRegionMap8regions_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- MemoryRegionMap::map_size_ -->
    <elf-symbol name='_ZN15MemoryRegionMap9map_size_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::kMaxStackDepth -->
    <elf-symbol name='_ZN16HeapProfileTable14kMaxStackDepthE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapProfileTable::kFileExt -->
    <elf-symbol name='_ZN16HeapProfileTable8kFileExtE' size='6' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- HeapLeakCheckerGlobalPrePost::count_ -->
    <elf-symbol name='_ZN28HeapLeakCheckerGlobalPrePost6count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::ElfMemImage::kInvalidBase -->
    <elf-symbol name='_ZN4base11ElfMemImage12kInvalidBaseE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- base::VDSOSupport::vdso_base_ -->
    <elf-symbol name='_ZN4base11VDSOSupport10vdso_base_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_mmap_log -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead14FLAGS_mmap_logE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nommap_log -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead16FLAGS_nommap_logE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_mmap_profile -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead18FLAGS_mmap_profileE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nommap_profile -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead20FLAGS_nommap_profileE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_skip_mmap -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_mmapE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_skip_sbrk -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_sbrkE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_report -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_heap_check_reportE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_only_mmap_profile -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_only_mmap_profileE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_skip_mmap -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_mmapE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_skip_sbrk -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_sbrkE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_report -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noheap_check_reportE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noonly_mmap_profile -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noonly_mmap_profileE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_cpu_profiler_unittest -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead27FLAGS_cpu_profiler_unittestE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_strict_check -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_heap_check_strict_checkE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nocpu_profiler_unittest -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_nocpu_profiler_unittestE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_run_under_gdb -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_heap_check_run_under_gdbE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_map_private -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_memfs_malloc_map_privateE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_cleanup_old_heap_profiles -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_cleanup_old_heap_profilesE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_identify_leaks -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_heap_check_identify_leaksE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_strict_check -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_noheap_check_strict_checkE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_abort_on_fail -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_memfs_malloc_abort_on_failE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_run_under_gdb -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_noheap_check_run_under_gdbE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_map_private -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_nomemfs_malloc_map_privateE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nocleanup_old_heap_profiles -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_nocleanup_old_heap_profilesE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_identify_leaks -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_noheap_check_identify_leaksE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_after_destructors -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_heap_check_after_destructorsE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_abort_on_fail -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_nomemfs_malloc_abort_on_failE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_ignore_global_live -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_global_liveE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_ignore_thread_live -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_thread_liveE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_disable_memory_release -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_malloc_disable_memory_releaseE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_ignore_mmap_fail -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_memfs_malloc_ignore_mmap_failE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_before_constructors -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_heap_check_before_constructorsE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_after_destructors -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_noheap_check_after_destructorsE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_ignore_global_live -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_global_liveE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_ignore_thread_live -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_thread_liveE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_disable_memory_release -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomalloc_disable_memory_releaseE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_ignore_mmap_fail -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomemfs_malloc_ignore_mmap_failE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_before_constructors -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead38FLAGS_noheap_check_before_constructorsE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_test_pointer_alignment -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead39FLAGS_heap_check_test_pointer_alignmentE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_test_pointer_alignment -->
    <elf-symbol name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead41FLAGS_noheap_check_test_pointer_alignmentE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_verbose -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead13FLAGS_verboseE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noverbose -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead15FLAGS_noverboseE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_malloc_devmem_limit -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_limitE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_malloc_devmem_start -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_startE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_max_leaks -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead26FLAGS_heap_check_max_leaksE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_nomalloc_devmem_limit -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_limitE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_nomalloc_devmem_start -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_startE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_max_leaks -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead28FLAGS_noheap_check_max_leaksE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_delay_seconds -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead30FLAGS_heap_check_delay_secondsE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_delay_seconds -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead32FLAGS_noheap_check_delay_secondsE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_pointer_source_alignment -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead41FLAGS_heap_check_pointer_source_alignmentE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_pointer_source_alignment -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead43FLAGS_noheap_check_pointer_source_alignmentE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_memfs_malloc_limit_mb -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead27FLAGS_memfs_malloc_limit_mbE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_heap_limit_mb -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead28FLAGS_tcmalloc_heap_limit_mbE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_nomemfs_malloc_limit_mb -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead29FLAGS_nomemfs_malloc_limit_mbE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_heap_limit_mb -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead30FLAGS_notcmalloc_heap_limit_mbE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_sample_parameter -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead31FLAGS_tcmalloc_sample_parameterE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_time_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead32FLAGS_heap_profile_time_intervalE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_inuse_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_heap_profile_inuse_intervalE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_sample_parameter -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_notcmalloc_sample_parameterE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_time_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead34FLAGS_noheap_profile_time_intervalE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_check_max_pointer_offset -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_heap_check_max_pointer_offsetE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_inuse_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_noheap_profile_inuse_intervalE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_check_max_pointer_offset -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead37FLAGS_noheap_check_max_pointer_offsetE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_allocation_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead38FLAGS_heap_profile_allocation_intervalE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_deallocation_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_heap_profile_deallocation_intervalE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_allocation_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_noheap_profile_allocation_intervalE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_deallocation_interval -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead42FLAGS_noheap_profile_deallocation_intervalE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_large_alloc_report_threshold -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead43FLAGS_tcmalloc_large_alloc_report_thresholdE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_large_alloc_report_threshold -->
    <elf-symbol name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead45FLAGS_notcmalloc_large_alloc_report_thresholdE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead::FLAGS_tcmalloc_release_rate -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead27FLAGS_tcmalloc_release_rateE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead::FLAGS_notcmalloc_release_rate -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead29FLAGS_notcmalloc_release_rateE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_check -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead16FLAGS_heap_checkE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_check -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead18FLAGS_noheap_checkE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_symbolize_pprof -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead21FLAGS_symbolize_pprofE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_memfs_malloc_path -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_memfs_malloc_pathE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_nosymbolize_pprof -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_nosymbolize_pprofE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_profile_pprof -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead24FLAGS_heap_profile_pprofE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_nomemfs_malloc_path -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead25FLAGS_nomemfs_malloc_pathE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_profile_pprof -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead26FLAGS_noheap_profile_pprofE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_check_dump_directory -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead31FLAGS_heap_check_dump_directoryE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_check_dump_directory -->
    <elf-symbol name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead33FLAGS_noheap_check_dump_directoryE' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- SpinLock::LINKER_INITIALIZED -->
    <elf-symbol name='_ZN8SpinLock18LINKER_INITIALIZEDE' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::tsd_inited_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache11tsd_inited_E' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::thread_heaps_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache13thread_heaps_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::threadlocal_data_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache17threadlocal_data_E' size='16' type='tls-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::next_memory_steal_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache18next_memory_steal_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::thread_heap_count_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache18thread_heap_count_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::per_thread_cache_size_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache22per_thread_cache_size_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::unclaimed_cache_space_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache22unclaimed_cache_space_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::overall_thread_cache_size_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache26overall_thread_cache_size_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::ThreadCache::heap_key_ -->
    <elf-symbol name='_ZN8tcmalloc11ThreadCache9heap_key_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::log_message_writer -->
    <elf-symbol name='_ZN8tcmalloc18log_message_writerE' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::threadcache_allocator -->
    <elf-symbol name='_ZN8tcmalloc21threadcache_allocatorE' size='32' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::central_cache_ -->
    <elf-symbol name='_ZN8tcmalloc6Static14central_cache_E' size='107008' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::growth_stacks_ -->
    <elf-symbol name='_ZN8tcmalloc6Static14growth_stacks_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::pageheap_lock_ -->
    <elf-symbol name='_ZN8tcmalloc6Static14pageheap_lock_E' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::span_allocator_ -->
    <elf-symbol name='_ZN8tcmalloc6Static15span_allocator_E' size='32' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::sampled_objects_ -->
    <elf-symbol name='_ZN8tcmalloc6Static16sampled_objects_E' size='48' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::bucket_allocator_ -->
    <elf-symbol name='_ZN8tcmalloc6Static17bucket_allocator_E' size='32' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::stacktrace_allocator_ -->
    <elf-symbol name='_ZN8tcmalloc6Static21stacktrace_allocator_E' size='32' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::sizemap_ -->
    <elf-symbol name='_ZN8tcmalloc6Static8sizemap_E' size='3936' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Static::pageheap_ -->
    <elf-symbol name='_ZN8tcmalloc6Static9pageheap_E' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- tcmalloc::Sampler::log_table_ -->
    <elf-symbol name='_ZN8tcmalloc7Sampler10log_table_E' size='8192' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_terminal -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep11_S_terminalE' size='1' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_empty_rep_storage -->
    <elf-symbol name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep20_S_empty_rep_storageE' size='32' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for SysAllocator -->
    <elf-symbol name='_ZTI12SysAllocator' size='16' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for MallocExtension -->
    <elf-symbol name='_ZTI15MallocExtension' size='16' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for MmapSysAllocator -->
    <elf-symbol name='_ZTI16MmapSysAllocator' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for SbrkSysAllocator -->
    <elf-symbol name='_ZTI16SbrkSysAllocator' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for DevMemSysAllocator -->
    <elf-symbol name='_ZTI18DevMemSysAllocator' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for DefaultSysAllocator -->
    <elf-symbol name='_ZTI19DefaultSysAllocator' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for HugetlbSysAllocator -->
    <elf-symbol name='_ZTI19HugetlbSysAllocator' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo for TCMallocImplementation -->
    <elf-symbol name='_ZTI22TCMallocImplementation' size='24' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for SysAllocator -->
    <elf-symbol name='_ZTS12SysAllocator' size='15' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for MallocExtension -->
    <elf-symbol name='_ZTS15MallocExtension' size='18' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for MmapSysAllocator -->
    <elf-symbol name='_ZTS16MmapSysAllocator' size='19' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for SbrkSysAllocator -->
    <elf-symbol name='_ZTS16SbrkSysAllocator' size='19' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for DevMemSysAllocator -->
    <elf-symbol name='_ZTS18DevMemSysAllocator' size='21' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for DefaultSysAllocator -->
    <elf-symbol name='_ZTS19DefaultSysAllocator' size='22' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for HugetlbSysAllocator -->
    <elf-symbol name='_ZTS19HugetlbSysAllocator' size='22' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- typeinfo name for TCMallocImplementation -->
    <elf-symbol name='_ZTS22TCMallocImplementation' size='25' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for SysAllocator -->
    <elf-symbol name='_ZTV12SysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for MallocExtension -->
    <elf-symbol name='_ZTV15MallocExtension' size='232' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for MmapSysAllocator -->
    <elf-symbol name='_ZTV16MmapSysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for SbrkSysAllocator -->
    <elf-symbol name='_ZTV16SbrkSysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for DevMemSysAllocator -->
    <elf-symbol name='_ZTV18DevMemSysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for DefaultSysAllocator -->
    <elf-symbol name='_ZTV19DefaultSysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for HugetlbSysAllocator -->
    <elf-symbol name='_ZTV19HugetlbSysAllocator' size='40' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- vtable for TCMallocImplementation -->
    <elf-symbol name='_ZTV22TCMallocImplementation' size='232' type='object-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kPageHeapType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE13kPageHeapType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kLargeSpanType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE14kLargeSpanType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kThreadCacheType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE16kThreadCacheType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kCentralCacheType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE17kCentralCacheType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kTransferCacheType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE18kTransferCacheType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kPageHeapUnmappedType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE21kPageHeapUnmappedType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*)::kLargeUnmappedSpanType -->
    <elf-symbol name='_ZZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EEE22kLargeUnmappedSpanType' size='8' type='object-type' binding='gnu-unique-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __free_hook -->
    <elf-symbol name='__free_hook' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __malloc_hook -->
    <elf-symbol name='__malloc_hook' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __memalign_hook -->
    <elf-symbol name='__memalign_hook' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- __realloc_hook -->
    <elf-symbol name='__realloc_hook' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- heap_leak_checker_bcad_variable -->
    <elf-symbol name='heap_leak_checker_bcad_variable' size='1' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
    <!-- sys_alloc -->
    <elf-symbol name='sys_alloc' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
  </elf-variable-symbols>
  <abi-instr version='1.0' address-size='64' path='src/base/atomicops-internals-x86.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/dynamic_annotations.c' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C89'>
    <!-- int RunningOnValgrind() -->
    <function-decl name='RunningOnValgrind' mangled-name='RunningOnValgrind' filepath='src/base/dynamic_annotations.c' line='152' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='RunningOnValgrind'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- double ValgrindSlowdown() -->
    <function-decl name='ValgrindSlowdown' mangled-name='ValgrindSlowdown' filepath='src/base/dynamic_annotations.c' line='166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ValgrindSlowdown'>
      <!-- double -->
      <return type-id='type-id-2'/>
    </function-decl>
    <!-- double -->
    <type-decl name='double' size-in-bits='64' id='type-id-2'/>
    <!-- int -->
    <type-decl name='int' size-in-bits='32' id='type-id-1'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/elf_mem_image.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- unsigned char[16] -->
    <array-type-def dimensions='1' type-id='type-id-3' size-in-bits='128' id='type-id-4'>
      <!-- <anonymous range>[16] -->
      <subrange length='16' type-id='type-id-5' id='type-id-6'/>
    </array-type-def>
    <!-- struct Elf64_Sym -->
    <class-decl name='Elf64_Sym' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/include/elf.h' line='389' column='1' id='type-id-7'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- Elf64_Word Elf64_Sym::st_name -->
        <var-decl name='st_name' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='390' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- unsigned char Elf64_Sym::st_info -->
        <var-decl name='st_info' type-id='type-id-3' visibility='default' filepath='/usr/include/elf.h' line='391' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='40'>
        <!-- unsigned char Elf64_Sym::st_other -->
        <var-decl name='st_other' type-id='type-id-3' visibility='default' filepath='/usr/include/elf.h' line='392' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='48'>
        <!-- Elf64_Section Elf64_Sym::st_shndx -->
        <var-decl name='st_shndx' type-id='type-id-9' visibility='default' filepath='/usr/include/elf.h' line='393' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- Elf64_Addr Elf64_Sym::st_value -->
        <var-decl name='st_value' type-id='type-id-10' visibility='default' filepath='/usr/include/elf.h' line='394' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- Elf64_Xword Elf64_Sym::st_size -->
        <var-decl name='st_size' type-id='type-id-11' visibility='default' filepath='/usr/include/elf.h' line='395' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef uint32_t Elf64_Word -->
    <typedef-decl name='Elf64_Word' type-id='type-id-12' filepath='/usr/include/elf.h' line='39' column='1' id='type-id-8'/>
    <!-- typedef uint16_t Elf64_Section -->
    <typedef-decl name='Elf64_Section' type-id='type-id-13' filepath='/usr/include/elf.h' line='58' column='1' id='type-id-9'/>
    <!-- typedef unsigned short int uint16_t -->
    <typedef-decl name='uint16_t' type-id='type-id-14' filepath='/usr/include/stdint.h' line='50' column='1' id='type-id-13'/>
    <!-- typedef uint64_t Elf64_Addr -->
    <typedef-decl name='Elf64_Addr' type-id='type-id-15' filepath='/usr/include/elf.h' line='50' column='1' id='type-id-10'/>
    <!-- typedef uint64_t Elf64_Xword -->
    <typedef-decl name='Elf64_Xword' type-id='type-id-15' filepath='/usr/include/elf.h' line='45' column='1' id='type-id-11'/>
    <!-- struct Elf64_Ehdr -->
    <class-decl name='Elf64_Ehdr' size-in-bits='512' is-struct='yes' visibility='default' filepath='/usr/include/elf.h' line='88' column='1' id='type-id-16'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- unsigned char Elf64_Ehdr::e_ident[16] -->
        <var-decl name='e_ident' type-id='type-id-4' visibility='default' filepath='/usr/include/elf.h' line='89' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- Elf64_Half Elf64_Ehdr::e_type -->
        <var-decl name='e_type' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='90' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='144'>
        <!-- Elf64_Half Elf64_Ehdr::e_machine -->
        <var-decl name='e_machine' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='91' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='160'>
        <!-- Elf64_Word Elf64_Ehdr::e_version -->
        <var-decl name='e_version' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='92' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- Elf64_Addr Elf64_Ehdr::e_entry -->
        <var-decl name='e_entry' type-id='type-id-10' visibility='default' filepath='/usr/include/elf.h' line='93' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- Elf64_Off Elf64_Ehdr::e_phoff -->
        <var-decl name='e_phoff' type-id='type-id-18' visibility='default' filepath='/usr/include/elf.h' line='94' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- Elf64_Off Elf64_Ehdr::e_shoff -->
        <var-decl name='e_shoff' type-id='type-id-18' visibility='default' filepath='/usr/include/elf.h' line='95' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- Elf64_Word Elf64_Ehdr::e_flags -->
        <var-decl name='e_flags' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='96' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='416'>
        <!-- Elf64_Half Elf64_Ehdr::e_ehsize -->
        <var-decl name='e_ehsize' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='97' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='432'>
        <!-- Elf64_Half Elf64_Ehdr::e_phentsize -->
        <var-decl name='e_phentsize' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='98' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='448'>
        <!-- Elf64_Half Elf64_Ehdr::e_phnum -->
        <var-decl name='e_phnum' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='99' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='464'>
        <!-- Elf64_Half Elf64_Ehdr::e_shentsize -->
        <var-decl name='e_shentsize' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='100' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='480'>
        <!-- Elf64_Half Elf64_Ehdr::e_shnum -->
        <var-decl name='e_shnum' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='101' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='496'>
        <!-- Elf64_Half Elf64_Ehdr::e_shstrndx -->
        <var-decl name='e_shstrndx' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='102' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef uint16_t Elf64_Half -->
    <typedef-decl name='Elf64_Half' type-id='type-id-13' filepath='/usr/include/elf.h' line='34' column='1' id='type-id-17'/>
    <!-- typedef uint64_t Elf64_Off -->
    <typedef-decl name='Elf64_Off' type-id='type-id-15' filepath='/usr/include/elf.h' line='54' column='1' id='type-id-18'/>
    <!-- typedef Elf64_Half Elf64_Versym -->
    <typedef-decl name='Elf64_Versym' type-id='type-id-17' filepath='/usr/include/elf.h' line='62' column='1' id='type-id-19'/>
    <!-- struct Elf64_Verdef -->
    <class-decl name='Elf64_Verdef' size-in-bits='160' is-struct='yes' visibility='default' filepath='/usr/include/elf.h' line='812' column='1' id='type-id-20'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- Elf64_Half Elf64_Verdef::vd_version -->
        <var-decl name='vd_version' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='813' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='16'>
        <!-- Elf64_Half Elf64_Verdef::vd_flags -->
        <var-decl name='vd_flags' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='814' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- Elf64_Half Elf64_Verdef::vd_ndx -->
        <var-decl name='vd_ndx' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='815' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='48'>
        <!-- Elf64_Half Elf64_Verdef::vd_cnt -->
        <var-decl name='vd_cnt' type-id='type-id-17' visibility='default' filepath='/usr/include/elf.h' line='816' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- Elf64_Word Elf64_Verdef::vd_hash -->
        <var-decl name='vd_hash' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='817' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='96'>
        <!-- Elf64_Word Elf64_Verdef::vd_aux -->
        <var-decl name='vd_aux' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='818' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- Elf64_Word Elf64_Verdef::vd_next -->
        <var-decl name='vd_next' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='819' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct Elf64_Phdr -->
    <class-decl name='Elf64_Phdr' size-in-bits='448' is-struct='yes' visibility='default' filepath='/usr/include/elf.h' line='551' column='1' id='type-id-21'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- Elf64_Word Elf64_Phdr::p_type -->
        <var-decl name='p_type' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='552' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- Elf64_Word Elf64_Phdr::p_flags -->
        <var-decl name='p_flags' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='553' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- Elf64_Off Elf64_Phdr::p_offset -->
        <var-decl name='p_offset' type-id='type-id-18' visibility='default' filepath='/usr/include/elf.h' line='554' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- Elf64_Addr Elf64_Phdr::p_vaddr -->
        <var-decl name='p_vaddr' type-id='type-id-10' visibility='default' filepath='/usr/include/elf.h' line='555' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- Elf64_Addr Elf64_Phdr::p_paddr -->
        <var-decl name='p_paddr' type-id='type-id-10' visibility='default' filepath='/usr/include/elf.h' line='556' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- Elf64_Xword Elf64_Phdr::p_filesz -->
        <var-decl name='p_filesz' type-id='type-id-11' visibility='default' filepath='/usr/include/elf.h' line='557' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- Elf64_Xword Elf64_Phdr::p_memsz -->
        <var-decl name='p_memsz' type-id='type-id-11' visibility='default' filepath='/usr/include/elf.h' line='558' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- Elf64_Xword Elf64_Phdr::p_align -->
        <var-decl name='p_align' type-id='type-id-11' visibility='default' filepath='/usr/include/elf.h' line='559' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct Elf64_Verdaux -->
    <class-decl name='Elf64_Verdaux' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/include/elf.h' line='849' column='1' id='type-id-22'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- Elf64_Word Elf64_Verdaux::vda_name -->
        <var-decl name='vda_name' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='850' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- Elf64_Word Elf64_Verdaux::vda_next -->
        <var-decl name='vda_next' type-id='type-id-8' visibility='default' filepath='/usr/include/elf.h' line='851' column='1'/>
      </data-member>
    </class-decl>
    <!-- base::ElfMemImage* -->
    <pointer-type-def type-id='type-id-23' size-in-bits='64' id='type-id-24'/>
    <!-- base::ElfMemImage::SymbolInfo* -->
    <pointer-type-def type-id='type-id-25' size-in-bits='64' id='type-id-26'/>
    <!-- base::ElfMemImage::SymbolIterator& -->
    <reference-type-def kind='lvalue' type-id='type-id-27' size-in-bits='64' id='type-id-28'/>
    <!-- base::ElfMemImage::SymbolIterator* -->
    <pointer-type-def type-id='type-id-27' size-in-bits='64' id='type-id-29'/>
    <!-- const Elf64_Ehdr -->
    <qualified-type-def type-id='type-id-16' const='yes' id='type-id-30'/>
    <!-- const Elf64_Ehdr* -->
    <pointer-type-def type-id='type-id-30' size-in-bits='64' id='type-id-31'/>
    <!-- const Elf64_Phdr -->
    <qualified-type-def type-id='type-id-21' const='yes' id='type-id-32'/>
    <!-- const Elf64_Phdr* -->
    <pointer-type-def type-id='type-id-32' size-in-bits='64' id='type-id-33'/>
    <!-- const Elf64_Sym -->
    <qualified-type-def type-id='type-id-7' const='yes' id='type-id-34'/>
    <!-- const Elf64_Sym* -->
    <pointer-type-def type-id='type-id-34' size-in-bits='64' id='type-id-35'/>
    <!-- const Elf64_Verdaux -->
    <qualified-type-def type-id='type-id-22' const='yes' id='type-id-36'/>
    <!-- const Elf64_Verdaux* -->
    <pointer-type-def type-id='type-id-36' size-in-bits='64' id='type-id-37'/>
    <!-- const Elf64_Verdef -->
    <qualified-type-def type-id='type-id-20' const='yes' id='type-id-38'/>
    <!-- const Elf64_Verdef* -->
    <pointer-type-def type-id='type-id-38' size-in-bits='64' id='type-id-39'/>
    <!-- const Elf64_Versym -->
    <qualified-type-def type-id='type-id-19' const='yes' id='type-id-40'/>
    <!-- const Elf64_Versym* -->
    <pointer-type-def type-id='type-id-40' size-in-bits='64' id='type-id-41'/>
    <!-- const Elf64_Word -->
    <qualified-type-def type-id='type-id-8' const='yes' id='type-id-42'/>
    <!-- const Elf64_Word* -->
    <pointer-type-def type-id='type-id-42' size-in-bits='64' id='type-id-43'/>
    <!-- const base::ElfMemImage -->
    <qualified-type-def type-id='type-id-23' const='yes' id='type-id-44'/>
    <!-- const base::ElfMemImage* -->
    <pointer-type-def type-id='type-id-44' size-in-bits='64' id='type-id-45'/>
    <!-- const base::ElfMemImage::SymbolInfo -->
    <qualified-type-def type-id='type-id-25' const='yes' id='type-id-46'/>
    <!-- const base::ElfMemImage::SymbolInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-46' size-in-bits='64' id='type-id-47'/>
    <!-- const base::ElfMemImage::SymbolInfo* -->
    <pointer-type-def type-id='type-id-46' size-in-bits='64' id='type-id-48'/>
    <!-- const base::ElfMemImage::SymbolIterator -->
    <qualified-type-def type-id='type-id-27' const='yes' id='type-id-49'/>
    <!-- const base::ElfMemImage::SymbolIterator& -->
    <reference-type-def kind='lvalue' type-id='type-id-49' size-in-bits='64' id='type-id-50'/>
    <!-- const base::ElfMemImage::SymbolIterator* -->
    <pointer-type-def type-id='type-id-49' size-in-bits='64' id='type-id-51'/>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- class base::ElfMemImage -->
      <class-decl name='ElfMemImage' size-in-bits='576' visibility='default' filepath='./src/base/elf_mem_image.h' line='56' column='1' id='type-id-23'>
        <member-type access='private'>
          <!-- struct base::ElfMemImage::SymbolInfo -->
          <class-decl name='SymbolInfo' size-in-bits='256' is-struct='yes' visibility='default' filepath='./src/base/elf_mem_image.h' line='64' column='1' id='type-id-25'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- const char* base::ElfMemImage::SymbolInfo::name -->
              <var-decl name='name' type-id='type-id-52' visibility='default' filepath='./src/base/elf_mem_image.h' line='65' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- const char* base::ElfMemImage::SymbolInfo::version -->
              <var-decl name='version' type-id='type-id-52' visibility='default' filepath='./src/base/elf_mem_image.h' line='66' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- void* base::ElfMemImage::SymbolInfo::address -->
              <var-decl name='address' type-id='type-id-53' visibility='default' filepath='./src/base/elf_mem_image.h' line='68' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='192'>
              <!-- const Elf64_Sym* base::ElfMemImage::SymbolInfo::symbol -->
              <var-decl name='symbol' type-id='type-id-35' visibility='default' filepath='./src/base/elf_mem_image.h' line='69' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- class base::ElfMemImage::SymbolIterator -->
          <class-decl name='SymbolIterator' size-in-bits='384' visibility='default' filepath='./src/base/elf_mem_image.h' line='73' column='1' id='type-id-27'>
            <data-member access='private' layout-offset-in-bits='0'>
              <!-- base::ElfMemImage::SymbolInfo base::ElfMemImage::SymbolIterator::info_ -->
              <var-decl name='info_' type-id='type-id-25' visibility='default' filepath='./src/base/elf_mem_image.h' line='84' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='256'>
              <!-- int base::ElfMemImage::SymbolIterator::index_ -->
              <var-decl name='index_' type-id='type-id-1' visibility='default' filepath='./src/base/elf_mem_image.h' line='85' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='320'>
              <!-- void* const base::ElfMemImage::SymbolIterator::image_ -->
              <var-decl name='image_' type-id='type-id-54' visibility='default' filepath='./src/base/elf_mem_image.h' line='86' column='1'/>
            </data-member>
            <member-function access='private'>
              <!-- const base::ElfMemImage::SymbolInfo* base::ElfMemImage::SymbolIterator::operator&#45;>() -->
              <function-decl name='operator-&gt;' mangled-name='_ZNK4base11ElfMemImage14SymbolIteratorptEv' filepath='./src/base/elf_mem_image.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage14SymbolIteratorptEv'>
                <!-- implicit parameter of type 'const base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-51' is-artificial='yes'/>
                <!-- const base::ElfMemImage::SymbolInfo* -->
                <return type-id='type-id-48'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- const base::ElfMemImage::SymbolInfo& base::ElfMemImage::SymbolIterator::operator*() -->
              <function-decl name='operator*' mangled-name='_ZNK4base11ElfMemImage14SymbolIteratordeEv' filepath='./src/base/elf_mem_image.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage14SymbolIteratordeEv'>
                <!-- implicit parameter of type 'const base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-51' is-artificial='yes'/>
                <!-- const base::ElfMemImage::SymbolInfo& -->
                <return type-id='type-id-47'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- base::ElfMemImage::SymbolIterator& base::ElfMemImage::SymbolIterator::operator++() -->
              <function-decl name='operator++' mangled-name='_ZN4base11ElfMemImage14SymbolIteratorppEv' filepath='./src/base/elf_mem_image.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11ElfMemImage14SymbolIteratorppEv'>
                <!-- implicit parameter of type 'base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-29' is-artificial='yes'/>
                <!-- base::ElfMemImage::SymbolIterator& -->
                <return type-id='type-id-28'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- bool base::ElfMemImage::SymbolIterator::operator!=(const base::ElfMemImage::SymbolIterator&) -->
              <function-decl name='operator!=' mangled-name='_ZNK4base11ElfMemImage14SymbolIteratorneERKS1_' filepath='./src/base/elf_mem_image.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage14SymbolIteratorneERKS1_'>
                <!-- implicit parameter of type 'const base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-51' is-artificial='yes'/>
                <!-- parameter of type 'const base::ElfMemImage::SymbolIterator&' -->
                <parameter type-id='type-id-50'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- bool base::ElfMemImage::SymbolIterator::operator==(const base::ElfMemImage::SymbolIterator&) -->
              <function-decl name='operator==' mangled-name='_ZNK4base11ElfMemImage14SymbolIteratoreqERKS1_' filepath='./src/base/elf_mem_image.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage14SymbolIteratoreqERKS1_'>
                <!-- implicit parameter of type 'const base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-51' is-artificial='yes'/>
                <!-- parameter of type 'const base::ElfMemImage::SymbolIterator&' -->
                <parameter type-id='type-id-50'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='private' constructor='yes'>
              <!-- base::ElfMemImage::SymbolIterator::SymbolIterator(void*, int) -->
              <function-decl name='SymbolIterator' mangled-name='_ZN4base11ElfMemImage14SymbolIteratorC2EPKvi' filepath='./src/base/elf_mem_image.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11ElfMemImage14SymbolIteratorC2EPKvi'>
                <!-- implicit parameter of type 'base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-29' is-artificial='yes'/>
                <!-- parameter of type 'void*' -->
                <parameter type-id='type-id-53'/>
                <!-- parameter of type 'int' -->
                <parameter type-id='type-id-1'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void base::ElfMemImage::SymbolIterator::Update(int) -->
              <function-decl name='Update' mangled-name='_ZN4base11ElfMemImage14SymbolIterator6UpdateEi' filepath='./src/base/elf_mem_image.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11ElfMemImage14SymbolIterator6UpdateEi'>
                <!-- implicit parameter of type 'base::ElfMemImage::SymbolIterator*' -->
                <parameter type-id='type-id-29' is-artificial='yes'/>
                <!-- parameter of type 'int' -->
                <parameter type-id='type-id-1'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='private' static='yes'>
          <!-- static void* const base::ElfMemImage::kInvalidBase -->
          <var-decl name='kInvalidBase' type-id='type-id-54' mangled-name='_ZN4base11ElfMemImage12kInvalidBaseE' visibility='default' filepath='./src/base/elf_mem_image.h' line='59' column='1' elf-symbol-id='_ZN4base11ElfMemImage12kInvalidBaseE'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- const Elf64_Ehdr* base::ElfMemImage::ehdr_ -->
          <var-decl name='ehdr_' type-id='type-id-31' visibility='default' filepath='./src/base/elf_mem_image.h' line='120' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- const Elf64_Sym* base::ElfMemImage::dynsym_ -->
          <var-decl name='dynsym_' type-id='type-id-35' visibility='default' filepath='./src/base/elf_mem_image.h' line='121' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- const Elf64_Versym* base::ElfMemImage::versym_ -->
          <var-decl name='versym_' type-id='type-id-41' visibility='default' filepath='./src/base/elf_mem_image.h' line='122' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- const Elf64_Verdef* base::ElfMemImage::verdef_ -->
          <var-decl name='verdef_' type-id='type-id-39' visibility='default' filepath='./src/base/elf_mem_image.h' line='123' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='256'>
          <!-- const Elf64_Word* base::ElfMemImage::hash_ -->
          <var-decl name='hash_' type-id='type-id-43' visibility='default' filepath='./src/base/elf_mem_image.h' line='124' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='320'>
          <!-- const char* base::ElfMemImage::dynstr_ -->
          <var-decl name='dynstr_' type-id='type-id-52' visibility='default' filepath='./src/base/elf_mem_image.h' line='125' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='384'>
          <!-- size_t base::ElfMemImage::strsize_ -->
          <var-decl name='strsize_' type-id='type-id-57' visibility='default' filepath='./src/base/elf_mem_image.h' line='126' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='448'>
          <!-- size_t base::ElfMemImage::verdefnum_ -->
          <var-decl name='verdefnum_' type-id='type-id-57' visibility='default' filepath='./src/base/elf_mem_image.h' line='127' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='512'>
          <!-- Elf64_Addr base::ElfMemImage::link_base_ -->
          <var-decl name='link_base_' type-id='type-id-10' visibility='default' filepath='./src/base/elf_mem_image.h' line='128' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- base::ElfMemImage::ElfMemImage(void*) -->
          <function-decl name='ElfMemImage' mangled-name='_ZN4base11ElfMemImageC1EPKv' filepath='./src/base/elf_mem_image.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11ElfMemImageC1EPKv'>
            <!-- implicit parameter of type 'base::ElfMemImage*' -->
            <parameter type-id='type-id-24' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void base::ElfMemImage::Init(void*) -->
          <function-decl name='Init' mangled-name='_ZN4base11ElfMemImage4InitEPKv' filepath='./src/base/elf_mem_image.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11ElfMemImage4InitEPKv'>
            <!-- implicit parameter of type 'base::ElfMemImage*' -->
            <parameter type-id='type-id-24' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::ElfMemImage::IsPresent() -->
          <function-decl name='IsPresent' mangled-name='_ZNK4base11ElfMemImage9IsPresentEv' filepath='./src/base/elf_mem_image.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const Elf64_Phdr* base::ElfMemImage::GetPhdr(int) -->
          <function-decl name='GetPhdr' mangled-name='_ZNK4base11ElfMemImage7GetPhdrEi' filepath='./src/base/elf_mem_image.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage7GetPhdrEi'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- const Elf64_Phdr* -->
            <return type-id='type-id-33'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const Elf64_Sym* base::ElfMemImage::GetDynsym(int) -->
          <function-decl name='GetDynsym' mangled-name='_ZNK4base11ElfMemImage9GetDynsymEi' filepath='./src/base/elf_mem_image.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage9GetDynsymEi'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- const Elf64_Sym* -->
            <return type-id='type-id-35'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const Elf64_Versym* base::ElfMemImage::GetVersym(int) -->
          <function-decl name='GetVersym' mangled-name='_ZNK4base11ElfMemImage9GetVersymEi' filepath='./src/base/elf_mem_image.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage9GetVersymEi'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- const Elf64_Versym* -->
            <return type-id='type-id-41'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const Elf64_Verdef* base::ElfMemImage::GetVerdef(int) -->
          <function-decl name='GetVerdef' mangled-name='_ZNK4base11ElfMemImage9GetVerdefEi' filepath='./src/base/elf_mem_image.h' line='96' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage9GetVerdefEi'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- const Elf64_Verdef* -->
            <return type-id='type-id-39'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const Elf64_Verdaux* base::ElfMemImage::GetVerdefAux(const Elf64_Verdef*) -->
          <function-decl name='GetVerdefAux' mangled-name='_ZNK4base11ElfMemImage12GetVerdefAuxEPK12Elf64_Verdef' filepath='./src/base/elf_mem_image.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage12GetVerdefAuxEPK12Elf64_Verdef'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'const Elf64_Verdef*' -->
            <parameter type-id='type-id-39'/>
            <!-- const Elf64_Verdaux* -->
            <return type-id='type-id-37'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* base::ElfMemImage::GetDynstr(Elf64_Word) -->
          <function-decl name='GetDynstr' mangled-name='_ZNK4base11ElfMemImage9GetDynstrEj' filepath='./src/base/elf_mem_image.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage9GetDynstrEj'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'typedef Elf64_Word' -->
            <parameter type-id='type-id-8'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* base::ElfMemImage::GetSymAddr(const Elf64_Sym*) -->
          <function-decl name='GetSymAddr' mangled-name='_ZNK4base11ElfMemImage10GetSymAddrEPK9Elf64_Sym' filepath='./src/base/elf_mem_image.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage10GetSymAddrEPK9Elf64_Sym'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'const Elf64_Sym*' -->
            <parameter type-id='type-id-35'/>
            <!-- void* -->
            <return type-id='type-id-53'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* base::ElfMemImage::GetVerstr(Elf64_Word) -->
          <function-decl name='GetVerstr' mangled-name='_ZNK4base11ElfMemImage9GetVerstrEj' filepath='./src/base/elf_mem_image.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage9GetVerstrEj'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'typedef Elf64_Word' -->
            <parameter type-id='type-id-8'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int base::ElfMemImage::GetNumSymbols() -->
          <function-decl name='GetNumSymbols' mangled-name='_ZNK4base11ElfMemImage13GetNumSymbolsEv' filepath='./src/base/elf_mem_image.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage13GetNumSymbolsEv'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- base::ElfMemImage::SymbolIterator base::ElfMemImage::begin() -->
          <function-decl name='begin' mangled-name='_ZNK4base11ElfMemImage5beginEv' filepath='./src/base/elf_mem_image.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage5beginEv'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- class base::ElfMemImage::SymbolIterator -->
            <return type-id='type-id-27'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- base::ElfMemImage::SymbolIterator base::ElfMemImage::end() -->
          <function-decl name='end' mangled-name='_ZNK4base11ElfMemImage3endEv' filepath='./src/base/elf_mem_image.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage3endEv'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- class base::ElfMemImage::SymbolIterator -->
            <return type-id='type-id-27'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::ElfMemImage::LookupSymbol(const char*, const char*, int, base::ElfMemImage::SymbolInfo*) -->
          <function-decl name='LookupSymbol' mangled-name='_ZNK4base11ElfMemImage12LookupSymbolEPKcS2_iPNS0_10SymbolInfoE' filepath='./src/base/elf_mem_image.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage12LookupSymbolEPKcS2_iPNS0_10SymbolInfoE'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'base::ElfMemImage::SymbolInfo*' -->
            <parameter type-id='type-id-26'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::ElfMemImage::LookupSymbolByAddress(void*, base::ElfMemImage::SymbolInfo*) -->
          <function-decl name='LookupSymbolByAddress' mangled-name='_ZNK4base11ElfMemImage21LookupSymbolByAddressEPKvPNS0_10SymbolInfoE' filepath='./src/base/elf_mem_image.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11ElfMemImage21LookupSymbolByAddressEPKvPNS0_10SymbolInfoE'>
            <!-- implicit parameter of type 'const base::ElfMemImage*' -->
            <parameter type-id='type-id-45' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- parameter of type 'base::ElfMemImage::SymbolInfo*' -->
            <parameter type-id='type-id-26'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- bool -->
    <type-decl name='bool' size-in-bits='8' id='type-id-55'/>
    <!-- const char* -->
    <pointer-type-def type-id='type-id-58' size-in-bits='64' id='type-id-52'/>
    <!-- typedef unsigned long int size_t -->
    <typedef-decl name='size_t' type-id='type-id-5' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/include/stddef.h' line='211' column='1' id='type-id-57'/>
    <!-- typedef unsigned int uint32_t -->
    <typedef-decl name='uint32_t' type-id='type-id-59' filepath='/usr/include/stdint.h' line='52' column='1' id='type-id-12'/>
    <!-- typedef unsigned long int uint64_t -->
    <typedef-decl name='uint64_t' type-id='type-id-5' filepath='/usr/include/stdint.h' line='56' column='1' id='type-id-15'/>
    <!-- unsigned char -->
    <type-decl name='unsigned char' size-in-bits='8' id='type-id-3'/>
    <!-- unsigned long int -->
    <type-decl name='unsigned long int' size-in-bits='64' id='type-id-5'/>
    <!-- unsigned short int -->
    <type-decl name='unsigned short int' size-in-bits='16' id='type-id-14'/>
    <!-- void -->
    <type-decl name='void' id='type-id-56'/>
    <!-- void* -->
    <pointer-type-def type-id='type-id-56' size-in-bits='64' id='type-id-53'/>
    <!-- void* const -->
    <qualified-type-def type-id='type-id-53' const='yes' id='type-id-54'/>
    <!-- const char -->
    <qualified-type-def type-id='type-id-60' const='yes' id='type-id-58'/>
    <!-- unsigned int -->
    <type-decl name='unsigned int' size-in-bits='32' id='type-id-59'/>
    <!-- char -->
    <type-decl name='char' size-in-bits='8' id='type-id-60'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/linuxthreads.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- typedef int (void*, int, pid_t*, typedef __va_list_tag __va_list_tag*)* ListAllProcessThreadsCallBack -->
    <typedef-decl name='ListAllProcessThreadsCallBack' type-id='type-id-61' filepath='./src/base/thread_lister.h' line='48' column='1' id='type-id-62'/>
    <!-- typedef __pid_t pid_t -->
    <typedef-decl name='pid_t' type-id='type-id-63' filepath='/usr/include/sched.h' line='37' column='1' id='type-id-64'/>
    <!-- typedef int __pid_t -->
    <typedef-decl name='__pid_t' type-id='type-id-1' filepath='/usr/include/bits/types.h' line='143' column='1' id='type-id-63'/>
    <!-- int (void*, int, pid_t*, typedef __va_list_tag __va_list_tag*)* -->
    <pointer-type-def type-id='type-id-65' size-in-bits='64' id='type-id-61'/>
    <!-- pid_t* -->
    <pointer-type-def type-id='type-id-64' size-in-bits='64' id='type-id-66'/>
    <!-- int TCMalloc_ListAllProcessThreads(void*, ListAllProcessThreadsCallBack, ...) -->
    <function-decl name='TCMalloc_ListAllProcessThreads' mangled-name='TCMalloc_ListAllProcessThreads' filepath='src/base/linuxthreads.cc' line='551' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='TCMalloc_ListAllProcessThreads'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='parameter' filepath='src/base/linuxthreads.cc' line='551' column='1'/>
      <!-- parameter of type 'typedef ListAllProcessThreadsCallBack' -->
      <parameter type-id='type-id-62' name='callback' filepath='src/base/linuxthreads.cc' line='552' column='1'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int TCMalloc_ResumeAllProcessThreads(int, pid_t*) -->
    <function-decl name='TCMalloc_ResumeAllProcessThreads' mangled-name='TCMalloc_ResumeAllProcessThreads' filepath='src/base/linuxthreads.cc' line='696' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='TCMalloc_ResumeAllProcessThreads'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='num_threads' filepath='src/base/linuxthreads.cc' line='696' column='1'/>
      <!-- parameter of type 'pid_t*' -->
      <parameter type-id='type-id-66' name='thread_pids' filepath='src/base/linuxthreads.cc' line='696' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int (void*, int, pid_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-type size-in-bits='64' id='type-id-65'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'pid_t*' -->
      <parameter type-id='type-id-66'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-type>
    <!-- typedef __va_list_tag __va_list_tag* -->
    <pointer-type-def type-id='type-id-68' size-in-bits='64' id='type-id-67'/>
    <!-- struct typedef __va_list_tag __va_list_tag -->
    <class-decl name='typedef __va_list_tag __va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='type-id-68'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- unsigned int typedef __va_list_tag __va_list_tag::gp_offset -->
        <var-decl name='gp_offset' type-id='type-id-59' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- unsigned int typedef __va_list_tag __va_list_tag::fp_offset -->
        <var-decl name='fp_offset' type-id='type-id-59' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- void* typedef __va_list_tag __va_list_tag::overflow_arg_area -->
        <var-decl name='overflow_arg_area' type-id='type-id-53' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- void* typedef __va_list_tag __va_list_tag::reg_save_area -->
        <var-decl name='reg_save_area' type-id='type-id-53' visibility='default'/>
      </data-member>
    </class-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/logging.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead'>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_verbose -->
      <var-decl name='FLAGS_verbose' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead13FLAGS_verboseE' visibility='default' filepath='./src/base/logging.h' line='76' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead13FLAGS_verboseE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noverbose -->
      <var-decl name='FLAGS_noverbose' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead15FLAGS_noverboseE' visibility='default' filepath='src/base/logging.cc' line='40' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead15FLAGS_noverboseE'/>
    </namespace-decl>
    <!-- void RawClose(RawFD) -->
    <function-decl name='RawClose' mangled-name='_Z8RawClosei' filepath='src/base/logging.cc' line='104' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z8RawClosei'>
      <!-- parameter of type 'typedef RawFD' -->
      <parameter type-id='type-id-70'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void RawWrite(RawFD, const char*, size_t) -->
    <function-decl name='RawWrite' mangled-name='_Z8RawWriteiPKcm' filepath='src/base/logging.cc' line='94' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z8RawWriteiPKcm'>
      <!-- parameter of type 'typedef RawFD' -->
      <parameter type-id='type-id-70' name='fd' filepath='src/base/logging.cc' line='94' column='1'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='buf' filepath='src/base/logging.cc' line='94' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='len' filepath='src/base/logging.cc' line='94' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- RawFD RawOpenForWriting(const char*) -->
    <function-decl name='RawOpenForWriting' mangled-name='_Z17RawOpenForWritingPKc' filepath='src/base/logging.cc' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z17RawOpenForWritingPKc'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='filename' filepath='src/base/logging.cc' line='90' column='1'/>
      <!-- typedef RawFD -->
      <return type-id='type-id-70'/>
    </function-decl>
    <!-- typedef int RawFD -->
    <typedef-decl name='RawFD' type-id='type-id-1' filepath='./src/base/logging.h' line='251' column='1' id='type-id-70'/>
    <!-- typedef int32_t int32 -->
    <typedef-decl name='int32' type-id='type-id-71' filepath='src/base/basictypes.h' line='60' column='1' id='type-id-69'/>
    <!-- typedef int int32_t -->
    <typedef-decl name='int32_t' type-id='type-id-1' filepath='/usr/include/stdint.h' line='39' column='1' id='type-id-71'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/low_level_alloc.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- AllocList*[30] -->
    <array-type-def dimensions='1' type-id='type-id-72' size-in-bits='1920' id='type-id-73'>
      <!-- <anonymous range>[30] -->
      <subrange length='30' type-id='type-id-5' id='type-id-74'/>
    </array-type-def>
    <!-- low_level_alloc_internal::AllocList* -->
    <pointer-type-def type-id='type-id-75' size-in-bits='64' id='type-id-72'/>
    <!-- namespace low_level_alloc_internal -->
    <namespace-decl name='low_level_alloc_internal'>
      <!-- struct low_level_alloc_internal::AllocList -->
      <class-decl name='AllocList' size-in-bits='2240' is-struct='yes' visibility='default' filepath='src/base/low_level_alloc.cc' line='67' column='1' id='type-id-75'>
        <member-type access='public'>
          <!-- struct low_level_alloc_internal::AllocList::Header -->
          <class-decl name='Header' size-in-bits='256' is-struct='yes' visibility='default' filepath='src/base/low_level_alloc.cc' line='68' column='1' id='type-id-76'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- intptr_t low_level_alloc_internal::AllocList::Header::size -->
              <var-decl name='size' type-id='type-id-77' visibility='default' filepath='src/base/low_level_alloc.cc' line='69' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- intptr_t low_level_alloc_internal::AllocList::Header::magic -->
              <var-decl name='magic' type-id='type-id-77' visibility='default' filepath='src/base/low_level_alloc.cc' line='71' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- LowLevelAlloc::Arena* low_level_alloc_internal::AllocList::Header::arena -->
              <var-decl name='arena' type-id='type-id-78' visibility='default' filepath='src/base/low_level_alloc.cc' line='72' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='192'>
              <!-- void* low_level_alloc_internal::AllocList::Header::dummy_for_alignment -->
              <var-decl name='dummy_for_alignment' type-id='type-id-53' visibility='default' filepath='src/base/low_level_alloc.cc' line='73' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- low_level_alloc_internal::AllocList::Header low_level_alloc_internal::AllocList::header -->
          <var-decl name='header' type-id='type-id-76' visibility='default' filepath='src/base/low_level_alloc.cc' line='74' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='256'>
          <!-- int low_level_alloc_internal::AllocList::levels -->
          <var-decl name='levels' type-id='type-id-1' visibility='default' filepath='src/base/low_level_alloc.cc' line='78' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='320'>
          <!-- low_level_alloc_internal::AllocList* low_level_alloc_internal::AllocList::next[30] -->
          <var-decl name='next' type-id='type-id-73' visibility='default' filepath='src/base/low_level_alloc.cc' line='79' column='1'/>
        </data-member>
      </class-decl>
    </namespace-decl>
    <!-- LowLevelAlloc::Arena* -->
    <pointer-type-def type-id='type-id-79' size-in-bits='64' id='type-id-78'/>
    <!-- typedef long int intptr_t -->
    <typedef-decl name='intptr_t' type-id='type-id-80' filepath='/usr/include/stdint.h' line='120' column='1' id='type-id-77'/>
    <!-- long int -->
    <type-decl name='long int' size-in-bits='64' id='type-id-80'/>
    <class-decl name='LowLevelAlloc' size-in-bits='8' visibility='default' filepath='src/base/low_level_alloc.h' line='44' column='1' id='type-id-81'>
      <member-type access='private'>
        <!-- struct LowLevelAlloc::Arena -->
        <class-decl name='Arena' size-in-bits='2560' is-struct='yes' visibility='default' filepath='src/base/low_level_alloc.cc' line='184' column='1' id='type-id-79'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- SpinLock LowLevelAlloc::Arena::mu -->
            <var-decl name='mu' type-id='type-id-82' visibility='default' filepath='src/base/low_level_alloc.cc' line='189' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- low_level_alloc_internal::AllocList LowLevelAlloc::Arena::freelist -->
            <var-decl name='freelist' type-id='type-id-75' visibility='default' filepath='src/base/low_level_alloc.cc' line='191' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2304'>
            <!-- int32 LowLevelAlloc::Arena::allocation_count -->
            <var-decl name='allocation_count' type-id='type-id-69' visibility='default' filepath='src/base/low_level_alloc.cc' line='192' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2336'>
            <!-- int32 LowLevelAlloc::Arena::flags -->
            <var-decl name='flags' type-id='type-id-69' visibility='default' filepath='src/base/low_level_alloc.cc' line='193' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2368'>
            <!-- size_t LowLevelAlloc::Arena::pagesize -->
            <var-decl name='pagesize' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='194' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2432'>
            <!-- size_t LowLevelAlloc::Arena::roundup -->
            <var-decl name='roundup' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='195' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2496'>
            <!-- size_t LowLevelAlloc::Arena::min_size -->
            <var-decl name='min_size' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='197' column='1'/>
          </data-member>
          <member-function access='public' constructor='yes'>
            <!-- LowLevelAlloc::Arena::Arena() -->
            <function-decl name='Arena' filepath='src/base/low_level_alloc.cc' line='185' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'LowLevelAlloc::Arena*' -->
              <parameter type-id='type-id-78' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' constructor='yes'>
            <!-- LowLevelAlloc::Arena::Arena(int) -->
            <function-decl name='Arena' filepath='src/base/low_level_alloc.cc' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'LowLevelAlloc::Arena*' -->
              <parameter type-id='type-id-78' is-artificial='yes'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
    </class-decl>
    <!-- class SpinLock -->
    <class-decl name='SpinLock' size-in-bits='32' visibility='default' filepath='./src/base/spinlock.h' line='48' column='1' id='type-id-82'>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__2 -->
        <enum-decl name='__anonymous_enum__2' is-anonymous='yes' filepath='./src/base/spinlock.h' line='116' column='1' id='type-id-83'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockSleeper' value='2'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__ -->
        <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='src/base/spinlock.h' line='114' column='1' id='type-id-85'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockFree' value='0'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__1 -->
        <enum-decl name='__anonymous_enum__1' is-anonymous='yes' filepath='src/base/spinlock.h' line='115' column='1' id='type-id-86'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockHeld' value='1'/>
        </enum-decl>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const base::LinkerInitialized SpinLock::LINKER_INITIALIZED -->
        <var-decl name='LINKER_INITIALIZED' type-id='type-id-87' mangled-name='_ZN8SpinLock18LINKER_INITIALIZEDE' visibility='default' filepath='src/base/spinlock.h' line='112' column='1' elf-symbol-id='_ZN8SpinLock18LINKER_INITIALIZEDE'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- volatile Atomic32 SpinLock::lockword_ -->
        <var-decl name='lockword_' type-id='type-id-88' visibility='default' filepath='src/base/spinlock.h' line='118' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock() -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='50' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock(base::LinkerInitialized) -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='61' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'enum base::LinkerInitialized' -->
          <parameter type-id='type-id-90'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::Lock() -->
        <function-decl name='Lock' mangled-name='_ZN8SpinLock4LockEv' filepath='src/base/spinlock.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool SpinLock::TryLock() -->
        <function-decl name='TryLock' mangled-name='_ZN8SpinLock7TryLockEv' filepath='src/base/spinlock.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::Unlock() -->
        <function-decl name='Unlock' mangled-name='_ZN8SpinLock6UnlockEv' filepath='src/base/spinlock.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool SpinLock::IsHeld() -->
        <function-decl name='IsHeld' mangled-name='_ZNK8SpinLock6IsHeldEv' filepath='src/base/spinlock.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const SpinLock*' -->
          <parameter type-id='type-id-91' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::SlowLock() -->
        <function-decl name='SlowLock' mangled-name='_ZN8SpinLock8SlowLockEv' filepath='src/base/spinlock.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock8SlowLockEv'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::SlowUnlock(uint64) -->
        <function-decl name='SlowUnlock' mangled-name='_ZN8SpinLock10SlowUnlockEm' filepath='src/base/spinlock.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock10SlowUnlockEm'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef uint64' -->
          <parameter type-id='type-id-92'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- Atomic32 SpinLock::SpinLoop(int64, Atomic32*) -->
        <function-decl name='SpinLoop' mangled-name='_ZN8SpinLock8SpinLoopElPi' filepath='src/base/spinlock.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock8SpinLoopElPi'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef int64' -->
          <parameter type-id='type-id-93'/>
          <!-- parameter of type 'Atomic32*' -->
          <parameter type-id='type-id-94'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- int32 SpinLock::CalculateWaitCycles(int64) -->
        <function-decl name='CalculateWaitCycles' mangled-name='_ZN8SpinLock19CalculateWaitCyclesEl' filepath='src/base/spinlock.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef int64' -->
          <parameter type-id='type-id-93'/>
          <!-- typedef int32 -->
          <return type-id='type-id-69'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock(const SpinLock&) -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'const SpinLock&' -->
          <parameter type-id='type-id-96'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::operator=(const SpinLock&) -->
        <function-decl name='operator=' mangled-name='_ZN8SpinLockaSERKS_' filepath='src/base/spinlock.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'const SpinLock&' -->
          <parameter type-id='type-id-96'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- Atomic32* -->
    <pointer-type-def type-id='type-id-95' size-in-bits='64' id='type-id-94'/>
    <!-- SpinLock* -->
    <pointer-type-def type-id='type-id-82' size-in-bits='64' id='type-id-89'/>
    <!-- const SpinLock& -->
    <reference-type-def kind='lvalue' type-id='type-id-97' size-in-bits='64' id='type-id-96'/>
    <!-- const SpinLock* -->
    <pointer-type-def type-id='type-id-97' size-in-bits='64' id='type-id-91'/>
    <!-- const base::LinkerInitialized -->
    <qualified-type-def type-id='type-id-90' const='yes' id='type-id-87'/>
    <namespace-decl name='base'>
      <!-- enum base::LinkerInitialized -->
      <enum-decl name='LinkerInitialized' filepath='src/base/basictypes.h' line='381' column='1' id='type-id-90'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='LINKER_INITIALIZED' value='0'/>
      </enum-decl>
    </namespace-decl>
    <!-- typedef int32_t Atomic32 -->
    <typedef-decl name='Atomic32' type-id='type-id-71' filepath='./src/base/atomicops-internals-x86.h' line='43' column='1' id='type-id-95'/>
    <!-- typedef int64_t int64 -->
    <typedef-decl name='int64' type-id='type-id-98' filepath='src/base/basictypes.h' line='61' column='1' id='type-id-93'/>
    <!-- typedef uint64_t uint64 -->
    <typedef-decl name='uint64' type-id='type-id-15' filepath='src/base/basictypes.h' line='72' column='1' id='type-id-92'/>
    <!-- volatile Atomic32 -->
    <qualified-type-def type-id='type-id-95' volatile='yes' id='type-id-88'/>
    <!-- const SpinLock -->
    <qualified-type-def type-id='type-id-82' const='yes' id='type-id-97'/>
    <!-- typedef long int int64_t -->
    <typedef-decl name='int64_t' type-id='type-id-80' filepath='/usr/include/stdint.h' line='41' column='1' id='type-id-98'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/spinlock.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- struct CycleClock -->
    <class-decl name='CycleClock' size-in-bits='8' is-struct='yes' visibility='default' filepath='./src/base/cycleclock.h' line='79' column='1' id='type-id-99'>
      <member-function access='public' static='yes'>
        <!-- int64 CycleClock::Now() -->
        <function-decl name='Now' mangled-name='_ZN10CycleClock3NowEv' filepath='./src/base/cycleclock.h' line='81' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- typedef int64 -->
          <return type-id='type-id-93'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- void base::SubmitSpinLockProfileData(void*, int64) -->
      <function-decl name='SubmitSpinLockProfileData' mangled-name='_ZN4base25SubmitSpinLockProfileDataEPKvl' filepath='./src/base/synchronization_profiling.h' line='48' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base25SubmitSpinLockProfileDataEPKvl'>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- parameter of type 'typedef int64' -->
        <parameter type-id='type-id-93'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/spinlock_internal.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- const base::internal::SpinLockWaitTransition -->
    <qualified-type-def type-id='type-id-100' const='yes' id='type-id-101'/>
    <!-- const base::internal::SpinLockWaitTransition* -->
    <pointer-type-def type-id='type-id-101' size-in-bits='64' id='type-id-102'/>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- namespace base::internal -->
      <namespace-decl name='internal'>
        <!-- struct base::internal::SpinLockWaitTransition -->
        <class-decl name='SpinLockWaitTransition' size-in-bits='96' is-struct='yes' visibility='default' filepath='./src/base/spinlock_internal.h' line='48' column='1' id='type-id-100'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- int32 base::internal::SpinLockWaitTransition::from -->
            <var-decl name='from' type-id='type-id-69' visibility='default' filepath='./src/base/spinlock_internal.h' line='49' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='32'>
            <!-- int32 base::internal::SpinLockWaitTransition::to -->
            <var-decl name='to' type-id='type-id-69' visibility='default' filepath='./src/base/spinlock_internal.h' line='50' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- bool base::internal::SpinLockWaitTransition::done -->
            <var-decl name='done' type-id='type-id-55' visibility='default' filepath='./src/base/spinlock_internal.h' line='51' column='1'/>
          </data-member>
        </class-decl>
        <!-- void base::internal::SpinLockWake(volatile Atomic32*, bool) -->
        <function-decl name='SpinLockWake' mangled-name='_ZN4base8internal12SpinLockWakeEPVib' filepath='./src/base/spinlock_linux-inl.h' line='96' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal12SpinLockWakeEPVib'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
        <!-- void base::internal::SpinLockDelay(volatile Atomic32*, int32, int) -->
        <function-decl name='SpinLockDelay' mangled-name='_ZN4base8internal13SpinLockDelayEPViii' filepath='./src/base/spinlock_linux-inl.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal13SpinLockDelayEPViii'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'typedef int32' -->
          <parameter type-id='type-id-69'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
        <!-- int32 base::internal::SpinLockWait(volatile Atomic32*, int, const base::internal::SpinLockWaitTransition*) -->
        <function-decl name='SpinLockWait' mangled-name='_ZN4base8internal12SpinLockWaitEPViiPKNS0_22SpinLockWaitTransitionE' filepath='src/base/spinlock_internal.cc' line='61' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal12SpinLockWaitEPViiPKNS0_22SpinLockWaitTransitionE'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'const base::internal::SpinLockWaitTransition*' -->
          <parameter type-id='type-id-102'/>
          <!-- typedef int32 -->
          <return type-id='type-id-69'/>
        </function-decl>
      </namespace-decl>
      <!-- namespace base::subtle -->
      <namespace-decl name='subtle'>
        <!-- Atomic32 base::subtle::Acquire_Load(const volatile Atomic32*) -->
        <function-decl name='Acquire_Load' filepath='./src/base/atomicops-internals-x86.h' line='167' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const volatile Atomic32*' -->
          <parameter type-id='type-id-104'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- const volatile Atomic32* -->
    <pointer-type-def type-id='type-id-105' size-in-bits='64' id='type-id-104'/>
    <!-- volatile Atomic32* -->
    <pointer-type-def type-id='type-id-88' size-in-bits='64' id='type-id-103'/>
    <!-- const volatile Atomic32 -->
    <qualified-type-def type-id='type-id-88' const='yes' id='type-id-105'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/sysinfo.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- char[10] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='80' id='type-id-106'>
      <!-- <anonymous range>[10] -->
      <subrange length='10' type-id='type-id-5' id='type-id-107'/>
    </array-type-def>
    <!-- char[5120] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='40960' id='type-id-108'>
      <!-- <anonymous range>[5120] -->
      <subrange length='5120' type-id='type-id-5' id='type-id-109'/>
    </array-type-def>
    <!-- class ProcMapsIterator -->
    <class-decl name='ProcMapsIterator' size-in-bits='640' visibility='default' filepath='./src/base/sysinfo.h' line='102' column='1' id='type-id-110'>
      <member-type access='private'>
        <!-- struct ProcMapsIterator::Buffer -->
        <class-decl name='Buffer' size-in-bits='40960' is-struct='yes' visibility='default' filepath='./src/base/sysinfo.h' line='104' column='1' id='type-id-111'>
          <data-member access='public' static='yes'>
            <!-- static const size_t ProcMapsIterator::Buffer::kBufSize -->
            <var-decl name='kBufSize' type-id='type-id-112' visibility='default' filepath='./src/base/sysinfo.h' line='110' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- char ProcMapsIterator::Buffer::buf_[5120] -->
            <var-decl name='buf_' type-id='type-id-108' visibility='default' filepath='./src/base/sysinfo.h' line='112' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- char* ProcMapsIterator::ibuf_ -->
        <var-decl name='ibuf_' type-id='type-id-113' visibility='default' filepath='./src/base/sysinfo.h' line='193' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- char* ProcMapsIterator::stext_ -->
        <var-decl name='stext_' type-id='type-id-113' visibility='default' filepath='./src/base/sysinfo.h' line='194' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- char* ProcMapsIterator::etext_ -->
        <var-decl name='etext_' type-id='type-id-113' visibility='default' filepath='./src/base/sysinfo.h' line='195' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- char* ProcMapsIterator::nextline_ -->
        <var-decl name='nextline_' type-id='type-id-113' visibility='default' filepath='./src/base/sysinfo.h' line='196' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- char* ProcMapsIterator::ebuf_ -->
        <var-decl name='ebuf_' type-id='type-id-113' visibility='default' filepath='./src/base/sysinfo.h' line='197' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='320'>
        <!-- int ProcMapsIterator::fd_ -->
        <var-decl name='fd_' type-id='type-id-1' visibility='default' filepath='./src/base/sysinfo.h' line='219' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='352'>
        <!-- pid_t ProcMapsIterator::pid_ -->
        <var-decl name='pid_' type-id='type-id-64' visibility='default' filepath='./src/base/sysinfo.h' line='221' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='384'>
        <!-- char ProcMapsIterator::flags_[10] -->
        <var-decl name='flags_' type-id='type-id-106' visibility='default' filepath='./src/base/sysinfo.h' line='222' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='512'>
        <!-- ProcMapsIterator::Buffer* ProcMapsIterator::dynamic_buffer_ -->
        <var-decl name='dynamic_buffer_' type-id='type-id-114' visibility='default' filepath='./src/base/sysinfo.h' line='223' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='576'>
        <!-- bool ProcMapsIterator::using_maps_backing_ -->
        <var-decl name='using_maps_backing_' type-id='type-id-55' visibility='default' filepath='./src/base/sysinfo.h' line='224' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- ProcMapsIterator::ProcMapsIterator(pid_t) -->
        <function-decl name='ProcMapsIterator' mangled-name='_ZN16ProcMapsIteratorC1Ei' filepath='./src/base/sysinfo.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIteratorC1Ei'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'typedef pid_t' -->
          <parameter type-id='type-id-64'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- ProcMapsIterator::ProcMapsIterator(pid_t, ProcMapsIterator::Buffer*) -->
        <function-decl name='ProcMapsIterator' mangled-name='_ZN16ProcMapsIteratorC2EiPNS_6BufferE' filepath='./src/base/sysinfo.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIteratorC2EiPNS_6BufferE'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'typedef pid_t' -->
          <parameter type-id='type-id-64'/>
          <!-- parameter of type 'ProcMapsIterator::Buffer*' -->
          <parameter type-id='type-id-114'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- ProcMapsIterator::ProcMapsIterator(pid_t, ProcMapsIterator::Buffer*, bool) -->
        <function-decl name='ProcMapsIterator' mangled-name='_ZN16ProcMapsIteratorC1EiPNS_6BufferEb' filepath='./src/base/sysinfo.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIteratorC1EiPNS_6BufferEb'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'typedef pid_t' -->
          <parameter type-id='type-id-64'/>
          <!-- parameter of type 'ProcMapsIterator::Buffer*' -->
          <parameter type-id='type-id-114'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProcMapsIterator::Valid() -->
        <function-decl name='Valid' mangled-name='_ZNK16ProcMapsIterator5ValidEv' filepath='./src/base/sysinfo.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16ProcMapsIterator5ValidEv'>
          <!-- implicit parameter of type 'const ProcMapsIterator*' -->
          <parameter type-id='type-id-116' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const char* ProcMapsIterator::CurrentLine() -->
        <function-decl name='CurrentLine' mangled-name='_ZNK16ProcMapsIterator11CurrentLineEv' filepath='./src/base/sysinfo.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const ProcMapsIterator*' -->
          <parameter type-id='type-id-116' is-artificial='yes'/>
          <!-- const char* -->
          <return type-id='type-id-52'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int ProcMapsIterator::FormatLine(int, uint64, uint64, const char*, uint64, int64, const char*, dev_t) -->
        <function-decl name='FormatLine' mangled-name='_ZN16ProcMapsIterator10FormatLineEPcimmPKcmlS2_m' filepath='./src/base/sysinfo.h' line='156' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIterator10FormatLineEPcimmPKcmlS2_m'>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef uint64' -->
          <parameter type-id='type-id-92'/>
          <!-- parameter of type 'typedef uint64' -->
          <parameter type-id='type-id-92'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef uint64' -->
          <parameter type-id='type-id-92'/>
          <!-- parameter of type 'typedef int64' -->
          <parameter type-id='type-id-93'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef dev_t' -->
          <parameter type-id='type-id-117'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProcMapsIterator::Next(uint64*, uint64*, char**, uint64*, int64*, char**) -->
        <function-decl name='Next' mangled-name='_ZN16ProcMapsIterator4NextEPmS0_PPcS0_PlS2_' filepath='./src/base/sysinfo.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIterator4NextEPmS0_PPcS0_PlS2_'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'char**' -->
          <parameter type-id='type-id-119'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'int64*' -->
          <parameter type-id='type-id-120'/>
          <!-- parameter of type 'char**' -->
          <parameter type-id='type-id-119'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProcMapsIterator::NextExt(uint64*, uint64*, char**, uint64*, int64*, char**, uint64*, uint64*, uint64*, uint64*, dev_t*) -->
        <function-decl name='NextExt' mangled-name='_ZN16ProcMapsIterator7NextExtEPmS0_PPcS0_PlS2_S0_S0_S0_S0_S0_' filepath='./src/base/sysinfo.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIterator7NextExtEPmS0_PPcS0_PlS2_S0_S0_S0_S0_S0_'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'char**' -->
          <parameter type-id='type-id-119'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'int64*' -->
          <parameter type-id='type-id-120'/>
          <!-- parameter of type 'char**' -->
          <parameter type-id='type-id-119'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'uint64*' -->
          <parameter type-id='type-id-118'/>
          <!-- parameter of type 'dev_t*' -->
          <parameter type-id='type-id-121'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- ProcMapsIterator::~ProcMapsIterator(int) -->
        <function-decl name='~ProcMapsIterator' mangled-name='_ZN16ProcMapsIteratorD1Ev' filepath='./src/base/sysinfo.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIteratorD1Ev'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProcMapsIterator::Init(pid_t, ProcMapsIterator::Buffer*, bool) -->
        <function-decl name='Init' mangled-name='_ZN16ProcMapsIterator4InitEiPNS_6BufferEb' filepath='./src/base/sysinfo.h' line='191' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16ProcMapsIterator4InitEiPNS_6BufferEb'>
          <!-- implicit parameter of type 'ProcMapsIterator*' -->
          <parameter type-id='type-id-115' is-artificial='yes'/>
          <!-- parameter of type 'typedef pid_t' -->
          <parameter type-id='type-id-64'/>
          <!-- parameter of type 'ProcMapsIterator::Buffer*' -->
          <parameter type-id='type-id-114'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef __dev_t dev_t -->
    <typedef-decl name='dev_t' type-id='type-id-122' filepath='/usr/include/sys/types.h' line='61' column='1' id='type-id-117'/>
    <!-- typedef unsigned long int __dev_t -->
    <typedef-decl name='__dev_t' type-id='type-id-5' filepath='/usr/include/bits/types.h' line='134' column='1' id='type-id-122'/>
    <!-- ProcMapsIterator* -->
    <pointer-type-def type-id='type-id-110' size-in-bits='64' id='type-id-115'/>
    <!-- ProcMapsIterator::Buffer* -->
    <pointer-type-def type-id='type-id-111' size-in-bits='64' id='type-id-114'/>
    <!-- const ProcMapsIterator -->
    <qualified-type-def type-id='type-id-110' const='yes' id='type-id-123'/>
    <!-- const ProcMapsIterator* -->
    <pointer-type-def type-id='type-id-123' size-in-bits='64' id='type-id-116'/>
    <!-- dev_t* -->
    <pointer-type-def type-id='type-id-117' size-in-bits='64' id='type-id-121'/>
    <!-- int64* -->
    <pointer-type-def type-id='type-id-93' size-in-bits='64' id='type-id-120'/>
    <!-- uint64* -->
    <pointer-type-def type-id='type-id-92' size-in-bits='64' id='type-id-118'/>
    <!-- bool HasPosixThreads() -->
    <function-decl name='HasPosixThreads' mangled-name='_Z15HasPosixThreadsv' filepath='src/base/sysinfo.cc' line='518' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z15HasPosixThreadsv'>
      <!-- bool -->
      <return type-id='type-id-55'/>
    </function-decl>
    <!-- void SleepForMilliseconds(int) -->
    <function-decl name='SleepForMilliseconds' mangled-name='_Z20SleepForMillisecondsi' filepath='src/base/sysinfo.cc' line='226' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z20SleepForMillisecondsi'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='milliseconds' filepath='src/base/sysinfo.cc' line='226' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int NumCPUs() -->
    <function-decl name='NumCPUs' mangled-name='_Z7NumCPUsv' filepath='src/base/sysinfo.cc' line='505' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z7NumCPUsv'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- double CyclesPerSecond() -->
    <function-decl name='CyclesPerSecond' mangled-name='_Z15CyclesPerSecondv' filepath='src/base/sysinfo.cc' line='500' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z15CyclesPerSecondv'>
      <!-- double -->
      <return type-id='type-id-2'/>
    </function-decl>
    <!-- bool GetUniquePathFromEnv(const char*, char*) -->
    <function-decl name='GetUniquePathFromEnv' mangled-name='_Z20GetUniquePathFromEnvPKcPc' filepath='src/base/sysinfo.cc' line='201' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z20GetUniquePathFromEnvPKcPc'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='env_name' filepath='src/base/sysinfo.cc' line='201' column='1'/>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113' name='path' filepath='src/base/sysinfo.cc' line='201' column='1'/>
      <!-- bool -->
      <return type-id='type-id-55'/>
    </function-decl>
    <!-- const char* GetenvBeforeMain(const char*) -->
    <function-decl name='GetenvBeforeMain' mangled-name='_Z16GetenvBeforeMainPKc' filepath='src/base/sysinfo.cc' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z16GetenvBeforeMainPKc'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='name' filepath='src/base/sysinfo.cc' line='122' column='1'/>
      <!-- const char* -->
      <return type-id='type-id-52'/>
    </function-decl>
    <!-- const char* TCMallocGetenvSafe(const char*) -->
    <function-decl name='TCMallocGetenvSafe' mangled-name='TCMallocGetenvSafe' filepath='src/base/sysinfo.cc' line='174' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='TCMallocGetenvSafe'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='name' filepath='src/base/sysinfo.cc' line='122' column='1'/>
      <!-- const char* -->
      <return type-id='type-id-52'/>
    </function-decl>
    <!-- char* -->
    <pointer-type-def type-id='type-id-60' size-in-bits='64' id='type-id-113'/>
    <!-- char** -->
    <pointer-type-def type-id='type-id-113' size-in-bits='64' id='type-id-119'/>
    <!-- const size_t -->
    <qualified-type-def type-id='type-id-57' const='yes' id='type-id-112'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/base/vdso_support.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- base::VDSOInitHelper* -->
    <pointer-type-def type-id='type-id-124' size-in-bits='64' id='type-id-125'/>
    <!-- base::VDSOSupport* -->
    <pointer-type-def type-id='type-id-126' size-in-bits='64' id='type-id-127'/>
    <!-- base::VDSOSupport::SymbolInfo* -->
    <pointer-type-def type-id='type-id-128' size-in-bits='64' id='type-id-129'/>
    <!-- const base::VDSOSupport -->
    <qualified-type-def type-id='type-id-126' const='yes' id='type-id-130'/>
    <!-- const base::VDSOSupport& -->
    <reference-type-def kind='lvalue' type-id='type-id-130' size-in-bits='64' id='type-id-131'/>
    <!-- const base::VDSOSupport* -->
    <pointer-type-def type-id='type-id-130' size-in-bits='64' id='type-id-132'/>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- class base::VDSOInitHelper -->
      <class-decl name='VDSOInitHelper' size-in-bits='8' visibility='default' filepath='src/base/vdso_support.cc' line='137' column='1' id='type-id-124'>
        <member-function access='private' constructor='yes'>
          <!-- base::VDSOInitHelper::VDSOInitHelper() -->
          <function-decl name='VDSOInitHelper' filepath='src/base/vdso_support.cc' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'base::VDSOInitHelper*' -->
            <parameter type-id='type-id-125' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class base::VDSOSupport -->
      <class-decl name='VDSOSupport' size-in-bits='576' visibility='default' filepath='./src/base/vdso_support.h' line='72' column='1' id='type-id-126'>
        <member-type access='private'>
          <!-- typedef base::ElfMemImage::SymbolInfo base::VDSOSupport::SymbolInfo -->
          <typedef-decl name='SymbolInfo' type-id='type-id-25' filepath='./src/base/vdso_support.h' line='76' column='1' id='type-id-128'/>
        </member-type>
        <member-type access='private'>
          <!-- typedef base::ElfMemImage::SymbolIterator base::VDSOSupport::SymbolIterator -->
          <typedef-decl name='SymbolIterator' type-id='type-id-27' filepath='./src/base/vdso_support.h' line='77' column='1' id='type-id-133'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- base::ElfMemImage base::VDSOSupport::image_ -->
          <var-decl name='image_' type-id='type-id-23' visibility='default' filepath='./src/base/vdso_support.h' line='112' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static void* base::VDSOSupport::vdso_base_ -->
          <var-decl name='vdso_base_' type-id='type-id-53' mangled-name='_ZN4base11VDSOSupport10vdso_base_E' visibility='default' filepath='./src/base/vdso_support.h' line='123' column='1' elf-symbol-id='_ZN4base11VDSOSupport10vdso_base_E'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- base::VDSOSupport::VDSOSupport() -->
          <function-decl name='VDSOSupport' mangled-name='_ZN4base11VDSOSupportC1Ev' filepath='./src/base/vdso_support.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11VDSOSupportC1Ev'>
            <!-- implicit parameter of type 'base::VDSOSupport*' -->
            <parameter type-id='type-id-127' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::VDSOSupport::IsPresent() -->
          <function-decl name='IsPresent' mangled-name='_ZNK4base11VDSOSupport9IsPresentEv' filepath='./src/base/vdso_support.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::VDSOSupport*' -->
            <parameter type-id='type-id-132' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- base::VDSOSupport::SymbolIterator base::VDSOSupport::begin() -->
          <function-decl name='begin' mangled-name='_ZNK4base11VDSOSupport5beginEv' filepath='./src/base/vdso_support.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::VDSOSupport*' -->
            <parameter type-id='type-id-132' is-artificial='yes'/>
            <!-- typedef base::VDSOSupport::SymbolIterator -->
            <return type-id='type-id-133'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- base::VDSOSupport::SymbolIterator base::VDSOSupport::end() -->
          <function-decl name='end' mangled-name='_ZNK4base11VDSOSupport3endEv' filepath='./src/base/vdso_support.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::VDSOSupport*' -->
            <parameter type-id='type-id-132' is-artificial='yes'/>
            <!-- typedef base::VDSOSupport::SymbolIterator -->
            <return type-id='type-id-133'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::VDSOSupport::LookupSymbol(const char*, const char*, int, base::VDSOSupport::SymbolInfo*) -->
          <function-decl name='LookupSymbol' mangled-name='_ZNK4base11VDSOSupport12LookupSymbolEPKcS2_iPNS_11ElfMemImage10SymbolInfoE' filepath='./src/base/vdso_support.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11VDSOSupport12LookupSymbolEPKcS2_iPNS_11ElfMemImage10SymbolInfoE'>
            <!-- implicit parameter of type 'const base::VDSOSupport*' -->
            <parameter type-id='type-id-132' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'base::VDSOSupport::SymbolInfo*' -->
            <parameter type-id='type-id-129'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool base::VDSOSupport::LookupSymbolByAddress(void*, base::VDSOSupport::SymbolInfo*) -->
          <function-decl name='LookupSymbolByAddress' mangled-name='_ZNK4base11VDSOSupport21LookupSymbolByAddressEPKvPNS_11ElfMemImage10SymbolInfoE' filepath='./src/base/vdso_support.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base11VDSOSupport21LookupSymbolByAddressEPKvPNS_11ElfMemImage10SymbolInfoE'>
            <!-- implicit parameter of type 'const base::VDSOSupport*' -->
            <parameter type-id='type-id-132' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- parameter of type 'base::VDSOSupport::SymbolInfo*' -->
            <parameter type-id='type-id-129'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* base::VDSOSupport::SetBase(void*) -->
          <function-decl name='SetBase' mangled-name='_ZN4base11VDSOSupport7SetBaseEPKv' filepath='./src/base/vdso_support.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11VDSOSupport7SetBaseEPKv'>
            <!-- implicit parameter of type 'base::VDSOSupport*' -->
            <parameter type-id='type-id-127' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void* -->
            <return type-id='type-id-53'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void* base::VDSOSupport::Init() -->
          <function-decl name='Init' mangled-name='_ZN4base11VDSOSupport4InitEv' filepath='./src/base/vdso_support.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base11VDSOSupport4InitEv'>
            <!-- void* -->
            <return type-id='type-id-53'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- base::VDSOSupport::VDSOSupport(const base::VDSOSupport&) -->
          <function-decl name='VDSOSupport' filepath='./src/base/vdso_support.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'base::VDSOSupport*' -->
            <parameter type-id='type-id-127' is-artificial='yes'/>
            <!-- parameter of type 'const base::VDSOSupport&' -->
            <parameter type-id='type-id-131'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void base::VDSOSupport::operator=(const base::VDSOSupport&) -->
          <function-decl name='operator=' mangled-name='_ZN4base11VDSOSupportaSERKS0_' filepath='./src/base/vdso_support.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'base::VDSOSupport*' -->
            <parameter type-id='type-id-127' is-artificial='yes'/>
            <!-- parameter of type 'const base::VDSOSupport&' -->
            <parameter type-id='type-id-131'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- namespace base::subtle -->
      <namespace-decl name='subtle'>
        <!-- void base::subtle::MemoryBarrier() -->
        <function-decl name='MemoryBarrier' mangled-name='_ZN4base6subtle13MemoryBarrierEv' filepath='./src/base/atomicops-internals-x86.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/central_freelist.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- const int& -->
    <reference-type-def kind='lvalue' type-id='type-id-134' size-in-bits='64' id='type-id-135'/>
    <!-- const int32_t -->
    <qualified-type-def type-id='type-id-71' const='yes' id='type-id-136'/>
    <!-- const int32_t& -->
    <reference-type-def kind='lvalue' type-id='type-id-136' size-in-bits='64' id='type-id-137'/>
    <!-- const tcmalloc::Span -->
    <qualified-type-def type-id='type-id-138' const='yes' id='type-id-139'/>
    <!-- const tcmalloc::Span* -->
    <pointer-type-def type-id='type-id-139' size-in-bits='64' id='type-id-140'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- const int& std::max<int>(const int&, const int&) -->
      <function-decl name='max&lt;int&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const int&' -->
        <parameter type-id='type-id-135'/>
        <!-- parameter of type 'const int&' -->
        <parameter type-id='type-id-135'/>
        <!-- const int& -->
        <return type-id='type-id-135'/>
      </function-decl>
      <!-- const int32_t& std::min<int32_t>(const int32_t&, const int32_t&) -->
      <function-decl name='min&lt;int32_t&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const int32_t&' -->
        <parameter type-id='type-id-137'/>
        <!-- parameter of type 'const int32_t&' -->
        <parameter type-id='type-id-137'/>
        <!-- const int32_t& -->
        <return type-id='type-id-137'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- bool tcmalloc::DLL_IsEmpty(const tcmalloc::Span*) -->
      <function-decl name='DLL_IsEmpty' filepath='src/span.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const tcmalloc::Span*' -->
        <parameter type-id='type-id-140'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void tcmalloc::SLL_PushRange(void**, void*, void*) -->
      <function-decl name='SLL_PushRange' filepath='src/linked_list.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
    </namespace-decl>
    <!-- const int -->
    <qualified-type-def type-id='type-id-1' const='yes' id='type-id-134'/>
    <namespace-decl name='tcmalloc'>
      <!-- struct tcmalloc::Span -->
      <class-decl name='Span' size-in-bits='384' is-struct='yes' visibility='default' filepath='src/span.h' line='45' column='1' id='type-id-138'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- PageID tcmalloc::Span::start -->
          <var-decl name='start' type-id='type-id-142' visibility='default' filepath='src/span.h' line='46' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- Length tcmalloc::Span::length -->
          <var-decl name='length' type-id='type-id-143' visibility='default' filepath='src/span.h' line='47' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- tcmalloc::Span* tcmalloc::Span::next -->
          <var-decl name='next' type-id='type-id-144' visibility='default' filepath='src/span.h' line='48' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='192'>
          <!-- tcmalloc::Span* tcmalloc::Span::prev -->
          <var-decl name='prev' type-id='type-id-144' visibility='default' filepath='src/span.h' line='49' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='256'>
          <!-- void* tcmalloc::Span::objects -->
          <var-decl name='objects' type-id='type-id-53' visibility='default' filepath='src/span.h' line='50' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='16'>
          <!-- unsigned int tcmalloc::Span::refcount -->
          <var-decl name='refcount' type-id='type-id-59' visibility='default' filepath='src/span.h' line='51' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='8'>
          <!-- unsigned int tcmalloc::Span::sizeclass -->
          <var-decl name='sizeclass' type-id='type-id-59' visibility='default' filepath='src/span.h' line='52' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='6'>
          <!-- unsigned int tcmalloc::Span::location -->
          <var-decl name='location' type-id='type-id-59' visibility='default' filepath='src/span.h' line='53' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='5'>
          <!-- unsigned int tcmalloc::Span::sample -->
          <var-decl name='sample' type-id='type-id-59' visibility='default' filepath='src/span.h' line='54' column='1'/>
        </data-member>
      </class-decl>
    </namespace-decl>
    <!-- void** -->
    <pointer-type-def type-id='type-id-53' size-in-bits='64' id='type-id-141'/>
    <!-- tcmalloc::Span* -->
    <pointer-type-def type-id='type-id-138' size-in-bits='64' id='type-id-144'/>
    <!-- typedef uintptr_t Length -->
    <typedef-decl name='Length' type-id='type-id-145' filepath='src/common.h' line='59' column='1' id='type-id-143'/>
    <!-- typedef uintptr_t PageID -->
    <typedef-decl name='PageID' type-id='type-id-145' filepath='src/common.h' line='56' column='1' id='type-id-142'/>
    <!-- typedef unsigned long int uintptr_t -->
    <typedef-decl name='uintptr_t' type-id='type-id-5' filepath='/usr/include/stdint.h' line='123' column='1' id='type-id-145'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/common.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- uint64_t tcmalloc::metadata_system_bytes() -->
      <function-decl name='metadata_system_bytes' mangled-name='_ZN8tcmalloc21metadata_system_bytesEv' filepath='src/common.cc' line='274' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc21metadata_system_bytesEv'>
        <!-- typedef uint64_t -->
        <return type-id='type-id-15'/>
      </function-decl>
      <!-- void* tcmalloc::MetaDataAlloc(size_t) -->
      <function-decl name='MetaDataAlloc' mangled-name='_ZN8tcmalloc13MetaDataAllocEm' filepath='src/common.cc' line='233' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc13MetaDataAllocEm'>
        <!-- parameter of type 'typedef size_t' -->
        <parameter type-id='type-id-57'/>
        <!-- void* -->
        <return type-id='type-id-53'/>
      </function-decl>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/heap-checker-bcad.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- class HeapLeakCheckerGlobalPrePost -->
    <class-decl name='HeapLeakCheckerGlobalPrePost' size-in-bits='8' visibility='default' filepath='src/heap-checker-bcad.cc' line='60' column='1' id='type-id-146'>
      <data-member access='private' static='yes'>
        <!-- static int HeapLeakCheckerGlobalPrePost::count_ -->
        <var-decl name='count_' type-id='type-id-1' mangled-name='_ZN28HeapLeakCheckerGlobalPrePost6count_E' visibility='default' filepath='src/heap-checker-bcad.cc' line='87' column='1' elf-symbol-id='_ZN28HeapLeakCheckerGlobalPrePost6count_E'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- HeapLeakCheckerGlobalPrePost::HeapLeakCheckerGlobalPrePost() -->
        <function-decl name='HeapLeakCheckerGlobalPrePost' filepath='src/heap-checker-bcad.cc' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakCheckerGlobalPrePost*' -->
          <parameter type-id='type-id-147' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- HeapLeakCheckerGlobalPrePost::~HeapLeakCheckerGlobalPrePost(int) -->
        <function-decl name='~HeapLeakCheckerGlobalPrePost' mangled-name='_ZN28HeapLeakCheckerGlobalPrePostD1Ev' filepath='src/heap-checker-bcad.cc' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN28HeapLeakCheckerGlobalPrePostD1Ev'>
          <!-- implicit parameter of type 'HeapLeakCheckerGlobalPrePost*' -->
          <parameter type-id='type-id-147' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- HeapLeakCheckerGlobalPrePost* -->
    <pointer-type-def type-id='type-id-146' size-in-bits='64' id='type-id-147'/>
    <!-- bool heap_leak_checker_bcad_variable -->
    <var-decl name='heap_leak_checker_bcad_variable' type-id='type-id-55' mangled-name='heap_leak_checker_bcad_variable' visibility='default' filepath='src/heap-checker-bcad.cc' line='53' column='1' elf-symbol-id='heap_leak_checker_bcad_variable'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/heap-checker.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- char[] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='infinite' id='type-id-148'>
      <!-- <anonymous range>[] -->
      <subrange length='infinite' id='type-id-149'/>
    </array-type-def>
    <!-- size_t[4] -->
    <array-type-def dimensions='1' type-id='type-id-57' size-in-bits='256' id='type-id-150'>
      <!-- <anonymous range>[4] -->
      <subrange length='4' type-id='type-id-5' id='type-id-151'/>
    </array-type-def>
    <!-- void*[32] -->
    <array-type-def dimensions='1' type-id='type-id-53' size-in-bits='2048' id='type-id-152'>
      <!-- <anonymous range>[32] -->
      <subrange length='32' type-id='type-id-5' id='type-id-153'/>
    </array-type-def>
    <!-- struct AllocObject -->
    <class-decl name='AllocObject' size-in-bits='192' is-struct='yes' visibility='default' filepath='src/heap-checker.cc' line='356' column='1' id='type-id-154'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- void* AllocObject::ptr -->
        <var-decl name='ptr' type-id='type-id-53' visibility='default' filepath='src/heap-checker.cc' line='357' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- uintptr_t AllocObject::size -->
        <var-decl name='size' type-id='type-id-145' visibility='default' filepath='src/heap-checker.cc' line='358' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- ObjectPlacement AllocObject::place -->
        <var-decl name='place' type-id='type-id-155' visibility='default' filepath='src/heap-checker.cc' line='359' column='1'/>
      </data-member>
      <member-function access='public' constructor='yes'>
        <!-- AllocObject::AllocObject(void*, size_t, ObjectPlacement) -->
        <function-decl name='AllocObject' filepath='src/heap-checker.cc' line='361' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AllocObject*' -->
          <parameter type-id='type-id-156' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'enum ObjectPlacement' -->
          <parameter type-id='type-id-155'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- enum ObjectPlacement -->
    <enum-decl name='ObjectPlacement' filepath='src/heap-checker.cc' line='345' column='1' id='type-id-155'>
      <underlying-type type-id='type-id-84'/>
      <enumerator name='MUST_BE_ON_HEAP' value='0'/>
      <enumerator name='IGNORED_ON_HEAP' value='1'/>
      <enumerator name='MAYBE_LIVE' value='2'/>
      <enumerator name='IN_GLOBAL_DATA' value='3'/>
      <enumerator name='THREAD_DATA' value='4'/>
      <enumerator name='THREAD_REGISTERS' value='5'/>
    </enum-decl>
    <!-- class STL_Allocator<AllocObject, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-157'>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-159'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AllocObject* STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::address(AllocObject&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE7addressERS0_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-160' is-artificial='yes'/>
          <!-- parameter of type 'AllocObject&' -->
          <parameter type-id='type-id-161'/>
          <!-- AllocObject* -->
          <return type-id='type-id-156'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const AllocObject* STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::address(const AllocObject&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE7addressERKS0_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-160' is-artificial='yes'/>
          <!-- parameter of type 'const AllocObject&' -->
          <parameter type-id='type-id-162'/>
          <!-- const AllocObject* -->
          <return type-id='type-id-163'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AllocObject* STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- AllocObject* -->
          <return type-id='type-id-156'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::deallocate(AllocObject*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE10deallocateEPS0_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'AllocObject*' -->
          <parameter type-id='type-id-156'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-160' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::construct(AllocObject*, const AllocObject&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE9constructEPS0_RKS0_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'AllocObject*' -->
          <parameter type-id='type-id-156'/>
          <!-- parameter of type 'const AllocObject&' -->
          <parameter type-id='type-id-162'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::construct(AllocObject*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE9constructEPS0_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'AllocObject*' -->
          <parameter type-id='type-id-156'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::destroy(AllocObject*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEE7destroyEPS0_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-158' is-artificial='yes'/>
          <!-- parameter of type 'AllocObject*' -->
          <parameter type-id='type-id-156'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<AllocObject, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEEeqERKS3_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-160' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-159'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct HeapProfileStats -->
    <class-decl name='HeapProfileStats' size-in-bits='192' is-struct='yes' visibility='default' filepath='src/heap-profile-stats.h' line='54' column='1' id='type-id-164'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int32 HeapProfileStats::allocs -->
        <var-decl name='allocs' type-id='type-id-69' visibility='default' filepath='src/heap-profile-stats.h' line='61' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int32 HeapProfileStats::frees -->
        <var-decl name='frees' type-id='type-id-69' visibility='default' filepath='src/heap-profile-stats.h' line='62' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int64 HeapProfileStats::alloc_size -->
        <var-decl name='alloc_size' type-id='type-id-93' visibility='default' filepath='src/heap-profile-stats.h' line='63' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- int64 HeapProfileStats::free_size -->
        <var-decl name='free_size' type-id='type-id-93' visibility='default' filepath='src/heap-profile-stats.h' line='64' column='1'/>
      </data-member>
      <member-function access='public'>
        <!-- bool HeapProfileStats::Equivalent(const HeapProfileStats&) -->
        <function-decl name='Equivalent' mangled-name='_ZNK16HeapProfileStats10EquivalentERKS_' filepath='src/heap-profile-stats.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const HeapProfileStats*' -->
          <parameter type-id='type-id-165' is-artificial='yes'/>
          <!-- parameter of type 'const HeapProfileStats&' -->
          <parameter type-id='type-id-166'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<void*, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-167'>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-169'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<void*, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void** STL_Allocator<void*, HeapLeakChecker::Allocator>::address(void*&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE7addressERS0_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-170' is-artificial='yes'/>
          <!-- parameter of type 'void*&' -->
          <parameter type-id='type-id-171'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void* const* STL_Allocator<void*, HeapLeakChecker::Allocator>::address(void* const&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE7addressERKS0_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-170' is-artificial='yes'/>
          <!-- parameter of type 'void* const&' -->
          <parameter type-id='type-id-172'/>
          <!-- void* const* -->
          <return type-id='type-id-173'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void** STL_Allocator<void*, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::deallocate(void**, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE10deallocateEPS0_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<void*, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-170' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::construct(void**, void* const&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE9constructEPS0_RKS0_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- parameter of type 'void* const&' -->
          <parameter type-id='type-id-172'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::construct(void**) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE9constructEPS0_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<void*, HeapLeakChecker::Allocator>::destroy(void**) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEE7destroyEPS0_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-168' is-artificial='yes'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<void*, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorIPvN15HeapLeakChecker9AllocatorEEeqERKS3_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-170' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-169'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class GoogleInitializer -->
    <class-decl name='GoogleInitializer' size-in-bits='128' visibility='default' filepath='src/base/googleinit.h' line='39' column='1' id='type-id-174'>
      <member-type access='private'>
        <!-- typedef void ()* GoogleInitializer::VoidFunction -->
        <typedef-decl name='VoidFunction' type-id='type-id-176' filepath='src/base/googleinit.h' line='41' column='1' id='type-id-175'/>
      </member-type>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- const char* const GoogleInitializer::name_ -->
        <var-decl name='name_' type-id='type-id-177' visibility='default' filepath='src/base/googleinit.h' line='55' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- const GoogleInitializer::VoidFunction GoogleInitializer::destructor_ -->
        <var-decl name='destructor_' type-id='type-id-178' visibility='default' filepath='src/base/googleinit.h' line='56' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- GoogleInitializer::GoogleInitializer(const char*, GoogleInitializer::VoidFunction, GoogleInitializer::VoidFunction) -->
        <function-decl name='GoogleInitializer' filepath='src/base/googleinit.h' line='42' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'GoogleInitializer*' -->
          <parameter type-id='type-id-179' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef GoogleInitializer::VoidFunction' -->
          <parameter type-id='type-id-175'/>
          <!-- parameter of type 'typedef GoogleInitializer::VoidFunction' -->
          <parameter type-id='type-id-175'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- GoogleInitializer::~GoogleInitializer(int) -->
        <function-decl name='~GoogleInitializer' mangled-name='_ZN17GoogleInitializerD2Ev' filepath='src/base/googleinit.h' line='48' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN17GoogleInitializerD2Ev'>
          <!-- implicit parameter of type 'GoogleInitializer*' -->
          <parameter type-id='type-id-179' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class MemoryRegionMap -->
    <class-decl name='MemoryRegionMap' size-in-bits='8' visibility='default' filepath='src/memory_region_map.h' line='69' column='1' id='type-id-180'>
      <member-type access='private'>
        <!-- struct MemoryRegionMap::RegionCmp -->
        <class-decl name='RegionCmp' size-in-bits='8' is-struct='yes' visibility='default' filepath='src/memory_region_map.h' line='245' column='1' id='type-id-181'>
          <member-function access='public'>
            <!-- bool MemoryRegionMap::RegionCmp::operator()(const MemoryRegionMap::Region&, const MemoryRegionMap::Region&) -->
            <function-decl name='operator()' mangled-name='_ZNK15MemoryRegionMap9RegionCmpclERKNS_6RegionES3_' filepath='src/memory_region_map.h' line='246' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const MemoryRegionMap::RegionCmp*' -->
              <parameter type-id='type-id-182' is-artificial='yes'/>
              <!-- parameter of type 'const MemoryRegionMap::Region&' -->
              <parameter type-id='type-id-183'/>
              <!-- parameter of type 'const MemoryRegionMap::Region&' -->
              <parameter type-id='type-id-183'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct MemoryRegionMap::Region -->
        <class-decl name='Region' size-in-bits='2304' is-struct='yes' visibility='default' filepath='src/memory_region_map.h' line='137' column='1' id='type-id-184'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- uintptr_t MemoryRegionMap::Region::start_addr -->
            <var-decl name='start_addr' type-id='type-id-145' visibility='default' filepath='src/memory_region_map.h' line='138' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- uintptr_t MemoryRegionMap::Region::end_addr -->
            <var-decl name='end_addr' type-id='type-id-145' visibility='default' filepath='src/memory_region_map.h' line='139' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- int MemoryRegionMap::Region::call_stack_depth -->
            <var-decl name='call_stack_depth' type-id='type-id-1' visibility='default' filepath='src/memory_region_map.h' line='140' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='192'>
            <!-- void* MemoryRegionMap::Region::call_stack[32] -->
            <var-decl name='call_stack' type-id='type-id-152' visibility='default' filepath='src/memory_region_map.h' line='141' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2240'>
            <!-- bool MemoryRegionMap::Region::is_stack -->
            <var-decl name='is_stack' type-id='type-id-55' visibility='default' filepath='src/memory_region_map.h' line='143' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- uintptr_t MemoryRegionMap::Region::caller() -->
            <function-decl name='caller' mangled-name='_ZNK15MemoryRegionMap6Region6callerEv' filepath='src/memory_region_map.h' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-185' is-artificial='yes'/>
              <!-- typedef uintptr_t -->
              <return type-id='type-id-145'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool MemoryRegionMap::Region::Overlaps(const MemoryRegionMap::Region&) -->
            <function-decl name='Overlaps' mangled-name='_ZNK15MemoryRegionMap6Region8OverlapsERKS0_' filepath='src/memory_region_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-185' is-artificial='yes'/>
              <!-- parameter of type 'const MemoryRegionMap::Region&' -->
              <parameter type-id='type-id-183'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::Create(void*, size_t) -->
            <function-decl name='Create' mangled-name='_ZN15MemoryRegionMap6Region6CreateEPKvm' filepath='src/memory_region_map.h' line='167' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'typedef size_t' -->
              <parameter type-id='type-id-57'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::set_call_stack_depth(int) -->
            <function-decl name='set_call_stack_depth' mangled-name='_ZN15MemoryRegionMap6Region20set_call_stack_depthEi' filepath='src/memory_region_map.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::set_is_stack() -->
            <function-decl name='set_is_stack' mangled-name='_ZN15MemoryRegionMap6Region12set_is_stackEv' filepath='src/memory_region_map.h' line='181' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::set_start_addr(uintptr_t) -->
            <function-decl name='set_start_addr' mangled-name='_ZN15MemoryRegionMap6Region14set_start_addrEm' filepath='src/memory_region_map.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- parameter of type 'typedef uintptr_t' -->
              <parameter type-id='type-id-145'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::set_end_addr(uintptr_t) -->
            <function-decl name='set_end_addr' mangled-name='_ZN15MemoryRegionMap6Region12set_end_addrEm' filepath='src/memory_region_map.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- parameter of type 'typedef uintptr_t' -->
              <parameter type-id='type-id-145'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::AssertIsConsistent() -->
            <function-decl name='AssertIsConsistent' mangled-name='_ZNK15MemoryRegionMap6Region18AssertIsConsistentEv' filepath='src/memory_region_map.h' line='192' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-185' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::Region::SetRegionSetKey(uintptr_t) -->
            <function-decl name='SetRegionSetKey' mangled-name='_ZN15MemoryRegionMap6Region15SetRegionSetKeyEm' filepath='src/memory_region_map.h' line='200' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::Region*' -->
              <parameter type-id='type-id-186' is-artificial='yes'/>
              <!-- parameter of type 'typedef uintptr_t' -->
              <parameter type-id='type-id-145'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct MemoryRegionMap::MyAllocator -->
        <class-decl name='MyAllocator' size-in-bits='8' is-struct='yes' visibility='default' filepath='src/memory_region_map.h' line='252' column='1' id='type-id-187'>
          <member-function access='public' static='yes'>
            <!-- void* MemoryRegionMap::MyAllocator::Allocate() -->
            <function-decl name='Allocate' mangled-name='_ZN15MemoryRegionMap11MyAllocator8AllocateEm' filepath='src/memory_region_map.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'typedef size_t' -->
              <parameter type-id='type-id-57'/>
              <!-- void* -->
              <return type-id='type-id-53'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void MemoryRegionMap::MyAllocator::Free(size_t) -->
            <function-decl name='Free' mangled-name='_ZN15MemoryRegionMap11MyAllocator4FreeEPKvm' filepath='src/memory_region_map.h' line='256' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'typedef size_t' -->
              <parameter type-id='type-id-57'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > MemoryRegionMap::RegionSet -->
        <typedef-decl name='RegionSet' type-id='type-id-189' filepath='src/memory_region_map.h' line='263' column='1' id='type-id-188'/>
      </member-type>
      <member-type access='private'>
        <!-- union MemoryRegionMap::RegionSetRep -->
        <union-decl name='RegionSetRep' size-in-bits='384' visibility='default' filepath='src/memory_region_map.cc' line='177' column='1' id='type-id-190'>
          <data-member access='private'>
            <!-- char MemoryRegionMap::RegionSetRep::rep[48] -->
            <var-decl name='rep' type-id='type-id-191' visibility='default' filepath='src/memory_region_map.cc' line='178' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- void* MemoryRegionMap::RegionSetRep::align_it -->
            <var-decl name='align_it' type-id='type-id-53' visibility='default' filepath='src/memory_region_map.cc' line='179' column='1'/>
          </data-member>
          <member-function access='private'>
            <!-- MemoryRegionMap::RegionSet* MemoryRegionMap::RegionSetRep::region_set() -->
            <function-decl name='region_set' mangled-name='_ZN15MemoryRegionMap12RegionSetRep10region_setEv' filepath='src/memory_region_map.cc' line='180' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::RegionSetRep*' -->
              <parameter type-id='type-id-192' is-artificial='yes'/>
              <!-- MemoryRegionMap::RegionSet* -->
              <return type-id='type-id-193'/>
            </function-decl>
          </member-function>
        </union-decl>
      </member-type>
      <member-type access='private'>
        <!-- class MemoryRegionMap::LockHolder -->
        <class-decl name='LockHolder' size-in-bits='8' visibility='default' filepath='src/memory_region_map.h' line='126' column='1' id='type-id-194'>
          <member-function access='private' constructor='yes'>
            <!-- MemoryRegionMap::LockHolder::LockHolder() -->
            <function-decl name='LockHolder' filepath='src/memory_region_map.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::LockHolder*' -->
              <parameter type-id='type-id-195' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' destructor='yes'>
            <!-- MemoryRegionMap::LockHolder::~LockHolder(int) -->
            <function-decl name='~LockHolder' filepath='src/memory_region_map.h' line='129' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::LockHolder*' -->
              <parameter type-id='type-id-195' is-artificial='yes'/>
              <!-- artificial parameter of type 'int' -->
              <parameter type-id='type-id-1' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' constructor='yes'>
            <!-- MemoryRegionMap::LockHolder::LockHolder(const MemoryRegionMap::LockHolder&) -->
            <function-decl name='LockHolder' filepath='src/memory_region_map.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::LockHolder*' -->
              <parameter type-id='type-id-195' is-artificial='yes'/>
              <!-- parameter of type 'const MemoryRegionMap::LockHolder&' -->
              <parameter type-id='type-id-196'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void MemoryRegionMap::LockHolder::operator=(const MemoryRegionMap::LockHolder&) -->
            <function-decl name='operator=' mangled-name='_ZN15MemoryRegionMap10LockHolderaSERKS0_' filepath='src/memory_region_map.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'MemoryRegionMap::LockHolder*' -->
              <parameter type-id='type-id-195' is-artificial='yes'/>
              <!-- parameter of type 'const MemoryRegionMap::LockHolder&' -->
              <parameter type-id='type-id-196'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef std::_Rb_tree_const_iterator<MemoryRegionMap::Region> MemoryRegionMap::RegionIterator -->
        <typedef-decl name='RegionIterator' type-id='type-id-198' filepath='src/memory_region_map.h' line='268' column='1' id='type-id-197'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static int MemoryRegionMap::client_count_ -->
        <var-decl name='client_count_' type-id='type-id-1' mangled-name='_ZN15MemoryRegionMap13client_count_E' visibility='default' filepath='src/memory_region_map.h' line='292' column='1' elf-symbol-id='_ZN15MemoryRegionMap13client_count_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int MemoryRegionMap::max_stack_depth_ -->
        <var-decl name='max_stack_depth_' type-id='type-id-1' mangled-name='_ZN15MemoryRegionMap16max_stack_depth_E' visibility='default' filepath='src/memory_region_map.h' line='295' column='1' elf-symbol-id='_ZN15MemoryRegionMap16max_stack_depth_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static LowLevelAlloc::Arena* MemoryRegionMap::arena_ -->
        <var-decl name='arena_' type-id='type-id-78' mangled-name='_ZN15MemoryRegionMap6arena_E' visibility='default' filepath='src/memory_region_map.h' line='298' column='1' elf-symbol-id='_ZN15MemoryRegionMap6arena_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static MemoryRegionMap::RegionSet* MemoryRegionMap::regions_ -->
        <var-decl name='regions_' type-id='type-id-193' mangled-name='_ZN15MemoryRegionMap8regions_E' visibility='default' filepath='src/memory_region_map.h' line='306' column='1' elf-symbol-id='_ZN15MemoryRegionMap8regions_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static SpinLock MemoryRegionMap::lock_ -->
        <var-decl name='lock_' type-id='type-id-82' mangled-name='_ZN15MemoryRegionMap5lock_E' visibility='default' filepath='src/memory_region_map.h' line='309' column='1' elf-symbol-id='_ZN15MemoryRegionMap5lock_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static SpinLock MemoryRegionMap::owner_lock_ -->
        <var-decl name='owner_lock_' type-id='type-id-82' mangled-name='_ZN15MemoryRegionMap11owner_lock_E' visibility='default' filepath='src/memory_region_map.h' line='311' column='1' elf-symbol-id='_ZN15MemoryRegionMap11owner_lock_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int MemoryRegionMap::recursion_count_ -->
        <var-decl name='recursion_count_' type-id='type-id-1' mangled-name='_ZN15MemoryRegionMap16recursion_count_E' visibility='default' filepath='src/memory_region_map.h' line='314' column='1' elf-symbol-id='_ZN15MemoryRegionMap16recursion_count_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static pthread_t MemoryRegionMap::lock_owner_tid_ -->
        <var-decl name='lock_owner_tid_' type-id='type-id-199' mangled-name='_ZN15MemoryRegionMap15lock_owner_tid_E' visibility='default' filepath='src/memory_region_map.h' line='316' column='1' elf-symbol-id='_ZN15MemoryRegionMap15lock_owner_tid_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int64 MemoryRegionMap::map_size_ -->
        <var-decl name='map_size_' type-id='type-id-93' mangled-name='_ZN15MemoryRegionMap9map_size_E' visibility='default' filepath='src/memory_region_map.h' line='319' column='1' elf-symbol-id='_ZN15MemoryRegionMap9map_size_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int64 MemoryRegionMap::unmap_size_ -->
        <var-decl name='unmap_size_' type-id='type-id-93' mangled-name='_ZN15MemoryRegionMap11unmap_size_E' visibility='default' filepath='src/memory_region_map.h' line='321' column='1' elf-symbol-id='_ZN15MemoryRegionMap11unmap_size_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static HeapProfileBucket** MemoryRegionMap::bucket_table_ -->
        <var-decl name='bucket_table_' type-id='type-id-200' mangled-name='_ZN15MemoryRegionMap13bucket_table_E' visibility='default' filepath='src/memory_region_map.h' line='324' column='1' elf-symbol-id='_ZN15MemoryRegionMap13bucket_table_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int MemoryRegionMap::num_buckets_ -->
        <var-decl name='num_buckets_' type-id='type-id-1' mangled-name='_ZN15MemoryRegionMap12num_buckets_E' visibility='default' filepath='src/memory_region_map.h' line='325' column='1' elf-symbol-id='_ZN15MemoryRegionMap12num_buckets_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static int MemoryRegionMap::saved_buckets_count_ -->
        <var-decl name='saved_buckets_count_' type-id='type-id-1' mangled-name='_ZN15MemoryRegionMap20saved_buckets_count_E' visibility='default' filepath='src/memory_region_map.h' line='337' column='1' elf-symbol-id='_ZN15MemoryRegionMap20saved_buckets_count_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static HeapProfileBucket MemoryRegionMap::saved_buckets_[20] -->
        <var-decl name='saved_buckets_' type-id='type-id-201' mangled-name='_ZN15MemoryRegionMap14saved_buckets_E' visibility='default' filepath='src/memory_region_map.h' line='343' column='1' elf-symbol-id='_ZN15MemoryRegionMap14saved_buckets_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static void* MemoryRegionMap::saved_buckets_keys_[20][32] -->
        <var-decl name='saved_buckets_keys_' type-id='type-id-202' mangled-name='_ZN15MemoryRegionMap19saved_buckets_keys_E' visibility='default' filepath='src/memory_region_map.h' line='345' column='1' elf-symbol-id='_ZN15MemoryRegionMap19saved_buckets_keys_E'/>
      </data-member>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::IterateBuckets<HeapProfileTable::BufferArgs*>(HeapProfileTable::BufferArgs*) -->
        <function-decl name='IterateBuckets&lt;HeapProfileTable::BufferArgs*&gt;' filepath='src/memory_region_map.h' line='402' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void (const HeapProfileBucket*, HeapProfileTable::BufferArgs*)*' -->
          <parameter type-id='type-id-203'/>
          <!-- parameter of type 'HeapProfileTable::BufferArgs*' -->
          <parameter type-id='type-id-204'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::Init(bool) -->
        <function-decl name='Init' mangled-name='_ZN15MemoryRegionMap4InitEib' filepath='src/memory_region_map.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap4InitEib'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MemoryRegionMap::Shutdown() -->
        <function-decl name='Shutdown' mangled-name='_ZN15MemoryRegionMap8ShutdownEv' filepath='src/memory_region_map.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap8ShutdownEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MemoryRegionMap::IsRecordingLocked() -->
        <function-decl name='IsRecordingLocked' mangled-name='_ZN15MemoryRegionMap17IsRecordingLockedEv' filepath='src/memory_region_map.h' line='113' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap17IsRecordingLockedEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::Lock() -->
        <function-decl name='Lock' mangled-name='_ZN15MemoryRegionMap4LockEv' filepath='src/memory_region_map.h' line='118' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap4LockEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::Unlock() -->
        <function-decl name='Unlock' mangled-name='_ZN15MemoryRegionMap6UnlockEv' filepath='src/memory_region_map.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap6UnlockEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MemoryRegionMap::LockIsHeld() -->
        <function-decl name='LockIsHeld' mangled-name='_ZN15MemoryRegionMap10LockIsHeldEv' filepath='src/memory_region_map.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap10LockIsHeldEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MemoryRegionMap::FindRegion(MemoryRegionMap::Region*) -->
        <function-decl name='FindRegion' mangled-name='_ZN15MemoryRegionMap10FindRegionEmPNS_6RegionE' filepath='src/memory_region_map.h' line='221' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap10FindRegionEmPNS_6RegionE'>
          <!-- parameter of type 'typedef uintptr_t' -->
          <parameter type-id='type-id-145'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MemoryRegionMap::FindAndMarkStackRegion(MemoryRegionMap::Region*) -->
        <function-decl name='FindAndMarkStackRegion' mangled-name='_ZN15MemoryRegionMap22FindAndMarkStackRegionEmPNS_6RegionE' filepath='src/memory_region_map.h' line='228' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap22FindAndMarkStackRegionEmPNS_6RegionE'>
          <!-- parameter of type 'typedef uintptr_t' -->
          <parameter type-id='type-id-145'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- HeapProfileBucket* MemoryRegionMap::GetBucket(void* const*) -->
        <function-decl name='GetBucket' mangled-name='_ZN15MemoryRegionMap9GetBucketEiPKPKv' filepath='src/memory_region_map.h' line='240' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap9GetBucketEiPKPKv'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void* const*' -->
          <parameter type-id='type-id-173'/>
          <!-- HeapProfileBucket* -->
          <return type-id='type-id-205'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MemoryRegionMap::RegionIterator MemoryRegionMap::BeginRegionLocked() -->
        <function-decl name='BeginRegionLocked' mangled-name='_ZN15MemoryRegionMap17BeginRegionLockedEv' filepath='src/memory_region_map.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap17BeginRegionLockedEv'>
          <!-- typedef MemoryRegionMap::RegionIterator -->
          <return type-id='type-id-197'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MemoryRegionMap::RegionIterator MemoryRegionMap::EndRegionLocked() -->
        <function-decl name='EndRegionLocked' mangled-name='_ZN15MemoryRegionMap15EndRegionLockedEv' filepath='src/memory_region_map.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap15EndRegionLockedEv'>
          <!-- typedef MemoryRegionMap::RegionIterator -->
          <return type-id='type-id-197'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- const MemoryRegionMap::Region* MemoryRegionMap::DoFindRegionLocked() -->
        <function-decl name='DoFindRegionLocked' mangled-name='_ZN15MemoryRegionMap18DoFindRegionLockedEm' filepath='src/memory_region_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap18DoFindRegionLockedEm'>
          <!-- parameter of type 'typedef uintptr_t' -->
          <parameter type-id='type-id-145'/>
          <!-- const MemoryRegionMap::Region* -->
          <return type-id='type-id-185'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::DoInsertRegionLocked() -->
        <function-decl name='DoInsertRegionLocked' mangled-name='_ZN15MemoryRegionMap20DoInsertRegionLockedERKNS_6RegionE' filepath='src/memory_region_map.h' line='355' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap20DoInsertRegionLockedERKNS_6RegionE'>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::HandleSavedRegionsLocked() -->
        <function-decl name='HandleSavedRegionsLocked' mangled-name='_ZN15MemoryRegionMap24HandleSavedRegionsLockedEPFvRKNS_6RegionEE' filepath='src/memory_region_map.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap24HandleSavedRegionsLockedEPFvRKNS_6RegionEE'>
          <!-- parameter of type 'void (const MemoryRegionMap::Region&)*' -->
          <parameter type-id='type-id-206'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::RestoreSavedBucketsLocked() -->
        <function-decl name='RestoreSavedBucketsLocked' mangled-name='_ZN15MemoryRegionMap25RestoreSavedBucketsLockedEv' filepath='src/memory_region_map.h' line='363' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap25RestoreSavedBucketsLockedEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::InsertRegionLocked() -->
        <function-decl name='InsertRegionLocked' mangled-name='_ZN15MemoryRegionMap18InsertRegionLockedERKNS_6RegionE' filepath='src/memory_region_map.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap18InsertRegionLockedERKNS_6RegionE'>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::RecordRegionAddition(size_t) -->
        <function-decl name='RecordRegionAddition' mangled-name='_ZN15MemoryRegionMap20RecordRegionAdditionEPKvm' filepath='src/memory_region_map.h' line='371' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap20RecordRegionAdditionEPKvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::RecordRegionRemoval(size_t) -->
        <function-decl name='RecordRegionRemoval' mangled-name='_ZN15MemoryRegionMap19RecordRegionRemovalEPKvm' filepath='src/memory_region_map.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap19RecordRegionRemovalEPKvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::RecordRegionRemovalInBucket(void* const*, size_t) -->
        <function-decl name='RecordRegionRemovalInBucket' mangled-name='_ZN15MemoryRegionMap27RecordRegionRemovalInBucketEiPKPKvm' filepath='src/memory_region_map.h' line='379' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap27RecordRegionRemovalInBucketEiPKPKvm'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void* const*' -->
          <parameter type-id='type-id-173'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::MmapHook(void*, size_t, int, int, int, off_t) -->
        <function-decl name='MmapHook' mangled-name='_ZN15MemoryRegionMap8MmapHookEPKvS1_miiil' filepath='src/memory_region_map.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap8MmapHookEPKvS1_miiil'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::MunmapHook(size_t) -->
        <function-decl name='MunmapHook' mangled-name='_ZN15MemoryRegionMap10MunmapHookEPKvm' filepath='src/memory_region_map.h' line='388' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap10MunmapHookEPKvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::MremapHook(void*, size_t, size_t, int, void*) -->
        <function-decl name='MremapHook' mangled-name='_ZN15MemoryRegionMap10MremapHookEPKvS1_mmiS1_' filepath='src/memory_region_map.h' line='389' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap10MremapHookEPKvS1_mmiS1_'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::SbrkHook(ptrdiff_t) -->
        <function-decl name='SbrkHook' mangled-name='_ZN15MemoryRegionMap8SbrkHookEPKvl' filepath='src/memory_region_map.h' line='392' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap8SbrkHookEPKvl'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef ptrdiff_t' -->
          <parameter type-id='type-id-208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MemoryRegionMap::LogAllLocked() -->
        <function-decl name='LogAllLocked' mangled-name='_ZN15MemoryRegionMap12LogAllLockedEv' filepath='src/memory_region_map.h' line='396' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MemoryRegionMap12LogAllLockedEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class HeapProfileTable -->
    <class-decl name='HeapProfileTable' size-in-bits='832' visibility='default' filepath='src/heap-profile-table.h' line='51' column='1' id='type-id-209'>
      <member-type access='private'>
        <!-- struct HeapProfileTable::AllocValue -->
        <class-decl name='AllocValue' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='190' column='1' id='type-id-210'>
          <member-type access='private'>
            <!-- typedef HeapProfileBucket HeapProfileTable::AllocValue::Bucket -->
            <typedef-decl name='Bucket' type-id='type-id-212' filepath='src/heap-profile-table.h' line='187' column='1' id='type-id-211'/>
          </member-type>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- size_t HeapProfileTable::AllocValue::bytes -->
            <var-decl name='bytes' type-id='type-id-57' visibility='default' filepath='src/heap-profile-table.h' line='197' column='1'/>
          </data-member>
          <data-member access='private' static='yes'>
            <!-- static const int HeapProfileTable::AllocValue::kLive -->
            <var-decl name='kLive' type-id='type-id-134' visibility='default' filepath='src/heap-profile-table.h' line='214' column='1'/>
          </data-member>
          <data-member access='private' static='yes'>
            <!-- static const int HeapProfileTable::AllocValue::kIgnore -->
            <var-decl name='kIgnore' type-id='type-id-134' visibility='default' filepath='src/heap-profile-table.h' line='215' column='1'/>
          </data-member>
          <data-member access='private' static='yes'>
            <!-- static const int HeapProfileTable::AllocValue::kMask -->
            <var-decl name='kMask' type-id='type-id-134' visibility='default' filepath='src/heap-profile-table.h' line='216' column='1'/>
          </data-member>
          <data-member access='private' layout-offset-in-bits='64'>
            <!-- uintptr_t HeapProfileTable::AllocValue::bucket_rep -->
            <var-decl name='bucket_rep' type-id='type-id-145' visibility='default' filepath='src/heap-profile-table.h' line='218' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- HeapProfileTable::AllocValue::Bucket* HeapProfileTable::AllocValue::bucket() -->
            <function-decl name='bucket' mangled-name='_ZNK16HeapProfileTable10AllocValue6bucketEv' filepath='src/heap-profile-table.h' line='192' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-213' is-artificial='yes'/>
              <!-- HeapProfileTable::AllocValue::Bucket* -->
              <return type-id='type-id-214'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::AllocValue::set_bucket(HeapProfileTable::AllocValue::Bucket*) -->
            <function-decl name='set_bucket' mangled-name='_ZN16HeapProfileTable10AllocValue10set_bucketEP17HeapProfileBucket' filepath='src/heap-profile-table.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-215' is-artificial='yes'/>
              <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*' -->
              <parameter type-id='type-id-214'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool HeapProfileTable::AllocValue::live() -->
            <function-decl name='live' mangled-name='_ZNK16HeapProfileTable10AllocValue4liveEv' filepath='src/heap-profile-table.h' line='200' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-213' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::AllocValue::set_live(bool) -->
            <function-decl name='set_live' mangled-name='_ZN16HeapProfileTable10AllocValue8set_liveEb' filepath='src/heap-profile-table.h' line='201' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-215' is-artificial='yes'/>
              <!-- parameter of type 'bool' -->
              <parameter type-id='type-id-55'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool HeapProfileTable::AllocValue::ignore() -->
            <function-decl name='ignore' mangled-name='_ZNK16HeapProfileTable10AllocValue6ignoreEv' filepath='src/heap-profile-table.h' line='206' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-213' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::AllocValue::set_ignore(bool) -->
            <function-decl name='set_ignore' mangled-name='_ZN16HeapProfileTable10AllocValue10set_ignoreEb' filepath='src/heap-profile-table.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-215' is-artificial='yes'/>
              <!-- parameter of type 'bool' -->
              <parameter type-id='type-id-55'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::DumpArgs -->
        <class-decl name='DumpArgs' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='242' column='1' id='type-id-216'>
          <member-type access='public'>
            <!-- typedef HeapProfileStats HeapProfileTable::DumpArgs::Stats -->
            <typedef-decl name='Stats' type-id='type-id-164' filepath='src/heap-profile-table.h' line='63' column='1' id='type-id-217'/>
          </member-type>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- RawFD HeapProfileTable::DumpArgs::fd -->
            <var-decl name='fd' type-id='type-id-70' visibility='default' filepath='src/heap-profile-table.h' line='248' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- HeapProfileTable::DumpArgs::Stats* HeapProfileTable::DumpArgs::profile_stats -->
            <var-decl name='profile_stats' type-id='type-id-218' visibility='default' filepath='src/heap-profile-table.h' line='249' column='1'/>
          </data-member>
          <member-function access='public' constructor='yes'>
            <!-- HeapProfileTable::DumpArgs::DumpArgs(RawFD, HeapProfileTable::DumpArgs::Stats*) -->
            <function-decl name='DumpArgs' filepath='src/heap-profile-table.h' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::DumpArgs*' -->
              <parameter type-id='type-id-219' is-artificial='yes'/>
              <!-- parameter of type 'typedef RawFD' -->
              <parameter type-id='type-id-70'/>
              <!-- parameter of type 'HeapProfileTable::DumpArgs::Stats*' -->
              <parameter type-id='type-id-218'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::Snapshot -->
        <class-decl name='Snapshot' size-in-bits='768' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='347' column='1' id='type-id-220'>
          <member-type access='private'>
            <!-- struct HeapProfileTable::Snapshot::Entry -->
            <class-decl name='Entry' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-profile-table.cc' line='514' column='1' id='type-id-221'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- int HeapProfileTable::Snapshot::Entry::count -->
                <var-decl name='count' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.cc' line='515' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- int HeapProfileTable::Snapshot::Entry::bytes -->
                <var-decl name='bytes' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.cc' line='516' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- HeapProfileTable::AllocValue::Bucket* HeapProfileTable::Snapshot::Entry::bucket -->
                <var-decl name='bucket' type-id='type-id-214' visibility='default' filepath='src/heap-profile-table.cc' line='517' column='1'/>
              </data-member>
              <member-function access='public' constructor='yes'>
                <!-- HeapProfileTable::Snapshot::Entry::Entry() -->
                <function-decl name='Entry' filepath='src/heap-profile-table.cc' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
                  <!-- implicit parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
                  <parameter type-id='type-id-222' is-artificial='yes'/>
                  <!-- void -->
                  <return type-id='type-id-56'/>
                </function-decl>
              </member-function>
              <member-function access='public'>
                <!-- bool HeapProfileTable::Snapshot::Entry::operator<(const HeapProfileTable::Snapshot::Entry&) -->
                <function-decl name='operator&lt;' mangled-name='_ZNK16HeapProfileTable8Snapshot5EntryltERKS1_' filepath='src/heap-profile-table.cc' line='521' column='1' visibility='default' binding='global' size-in-bits='64'>
                  <!-- implicit parameter of type 'const HeapProfileTable::Snapshot::Entry*' -->
                  <parameter type-id='type-id-223' is-artificial='yes'/>
                  <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
                  <parameter type-id='type-id-224'/>
                  <!-- bool -->
                  <return type-id='type-id-55'/>
                </function-decl>
              </member-function>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct HeapProfileTable::Snapshot::ReportState -->
            <class-decl name='ReportState' size-in-bits='384' is-struct='yes' visibility='default' filepath='src/heap-profile-table.cc' line='528' column='1' id='type-id-225'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > HeapProfileTable::Snapshot::ReportState::buckets_ -->
                <var-decl name='buckets_' type-id='type-id-226' visibility='default' filepath='src/heap-profile-table.cc' line='529' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <data-member access='private' layout-offset-in-bits='0'>
            <!-- HeapProfileTable::AllocValue::Bucket HeapProfileTable::Snapshot::total_ -->
            <var-decl name='total_' type-id='type-id-211' visibility='default' filepath='src/heap-profile-table.h' line='372' column='1'/>
          </data-member>
          <data-member access='private' layout-offset-in-bits='448'>
            <!-- HeapProfileTable::AllocationMap HeapProfileTable::Snapshot::map_ -->
            <var-decl name='map_' type-id='type-id-227' visibility='default' filepath='src/heap-profile-table.h' line='376' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- const HeapProfileTable::DumpArgs::Stats& HeapProfileTable::Snapshot::total() -->
            <function-decl name='total' mangled-name='_ZNK16HeapProfileTable8Snapshot5totalEv' filepath='src/heap-profile-table.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-228' is-artificial='yes'/>
              <!-- const HeapProfileTable::DumpArgs::Stats& -->
              <return type-id='type-id-229'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::Snapshot::ReportLeaks(const char*, const char*, bool) -->
            <function-decl name='ReportLeaks' mangled-name='_ZN16HeapProfileTable8Snapshot11ReportLeaksEPKcS2_b' filepath='src/heap-profile-table.h' line='357' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable8Snapshot11ReportLeaksEPKcS2_b'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- parameter of type 'const char*' -->
              <parameter type-id='type-id-52'/>
              <!-- parameter of type 'const char*' -->
              <parameter type-id='type-id-52'/>
              <!-- parameter of type 'bool' -->
              <parameter type-id='type-id-55'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::Snapshot::ReportIndividualObjects() -->
            <function-decl name='ReportIndividualObjects' mangled-name='_ZN16HeapProfileTable8Snapshot23ReportIndividualObjectsEv' filepath='src/heap-profile-table.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable8Snapshot23ReportIndividualObjectsEv'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool HeapProfileTable::Snapshot::Empty() -->
            <function-decl name='Empty' mangled-name='_ZNK16HeapProfileTable8Snapshot5EmptyEv' filepath='src/heap-profile-table.h' line='364' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-228' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='private' constructor='yes'>
            <!-- HeapProfileTable::Snapshot::Snapshot(HeapProfileTable::Allocator, HeapProfileTable::DeAllocator) -->
            <function-decl name='Snapshot' filepath='src/heap-profile-table.h' line='378' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- parameter of type 'typedef HeapProfileTable::Allocator' -->
              <parameter type-id='type-id-231'/>
              <!-- parameter of type 'typedef HeapProfileTable::DeAllocator' -->
              <parameter type-id='type-id-232'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void HeapProfileTable::Snapshot::Add(void*, const HeapProfileTable::AllocValue&) -->
            <function-decl name='Add' mangled-name='_ZN16HeapProfileTable8Snapshot3AddEPKvRKNS_10AllocValueE' filepath='src/heap-profile-table.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'const HeapProfileTable::AllocValue&' -->
              <parameter type-id='type-id-233'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' static='yes'>
            <!-- void HeapProfileTable::Snapshot::ReportCallback(HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*) -->
            <function-decl name='ReportCallback' mangled-name='_ZN16HeapProfileTable8Snapshot14ReportCallbackEPKvPNS_10AllocValueEPNS0_11ReportStateE' filepath='src/heap-profile-table.h' line='393' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable8Snapshot14ReportCallbackEPKvPNS_10AllocValueEPNS0_11ReportStateE'>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-215'/>
              <!-- parameter of type 'HeapProfileTable::Snapshot::ReportState*' -->
              <parameter type-id='type-id-234'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' static='yes'>
            <!-- void HeapProfileTable::Snapshot::ReportObject(HeapProfileTable::AllocValue*, char*) -->
            <function-decl name='ReportObject' mangled-name='_ZN16HeapProfileTable8Snapshot12ReportObjectEPKvPNS_10AllocValueEPc' filepath='src/heap-profile-table.h' line='394' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable8Snapshot12ReportObjectEPKvPNS_10AllocValueEPc'>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
              <parameter type-id='type-id-215'/>
              <!-- parameter of type 'char*' -->
              <parameter type-id='type-id-113'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' constructor='yes'>
            <!-- HeapProfileTable::Snapshot::Snapshot(const HeapProfileTable::Snapshot&) -->
            <function-decl name='Snapshot' filepath='src/heap-profile-table.h' line='396' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- parameter of type 'const HeapProfileTable::Snapshot&' -->
              <parameter type-id='type-id-235'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void HeapProfileTable::Snapshot::operator=(const HeapProfileTable::Snapshot&) -->
            <function-decl name='operator=' mangled-name='_ZN16HeapProfileTable8SnapshotaSERKS0_' filepath='src/heap-profile-table.h' line='396' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::Snapshot*' -->
              <parameter type-id='type-id-230' is-artificial='yes'/>
              <!-- parameter of type 'const HeapProfileTable::Snapshot&' -->
              <parameter type-id='type-id-235'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::AddNonLiveArgs -->
        <class-decl name='AddNonLiveArgs' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='305' column='1' id='type-id-236'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- HeapProfileTable::Snapshot* HeapProfileTable::AddNonLiveArgs::dest -->
            <var-decl name='dest' type-id='type-id-230' visibility='default' filepath='src/heap-profile-table.h' line='306' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- HeapProfileTable::Snapshot* HeapProfileTable::AddNonLiveArgs::base -->
            <var-decl name='base' type-id='type-id-230' visibility='default' filepath='src/heap-profile-table.h' line='307' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::AllocInfo -->
        <class-decl name='AllocInfo' size-in-bits='192' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='66' column='1' id='type-id-237'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- size_t HeapProfileTable::AllocInfo::object_size -->
            <var-decl name='object_size' type-id='type-id-57' visibility='default' filepath='src/heap-profile-table.h' line='67' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- void* const* HeapProfileTable::AllocInfo::call_stack -->
            <var-decl name='call_stack' type-id='type-id-173' visibility='default' filepath='src/heap-profile-table.h' line='68' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- int HeapProfileTable::AllocInfo::stack_depth -->
            <var-decl name='stack_depth' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.h' line='69' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='160'>
            <!-- bool HeapProfileTable::AllocInfo::live -->
            <var-decl name='live' type-id='type-id-55' visibility='default' filepath='src/heap-profile-table.h' line='70' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='168'>
            <!-- bool HeapProfileTable::AllocInfo::ignored -->
            <var-decl name='ignored' type-id='type-id-55' visibility='default' filepath='src/heap-profile-table.h' line='71' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::AllocContextInfo -->
        <class-decl name='AllocContextInfo' size-in-bits='320' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='77' column='1' id='type-id-238'>
          <!-- struct HeapProfileStats -->
          <base-class access='public' layout-offset-in-bits='0' type-id='type-id-164'/>
          <data-member access='public' layout-offset-in-bits='192'>
            <!-- int HeapProfileTable::AllocContextInfo::stack_depth -->
            <var-decl name='stack_depth' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.h' line='78' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='256'>
            <!-- void* const* HeapProfileTable::AllocContextInfo::call_stack -->
            <var-decl name='call_stack' type-id='type-id-173' visibility='default' filepath='src/heap-profile-table.h' line='79' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef void* (typedef size_t)* HeapProfileTable::Allocator -->
        <typedef-decl name='Allocator' type-id='type-id-239' filepath='src/heap-profile-table.h' line='83' column='1' id='type-id-231'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef void (void*)* HeapProfileTable::DeAllocator -->
        <typedef-decl name='DeAllocator' type-id='type-id-240' filepath='src/heap-profile-table.h' line='84' column='1' id='type-id-232'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef AddressMap<HeapProfileTable::AllocValue> HeapProfileTable::AllocationMap -->
        <typedef-decl name='AllocationMap' type-id='type-id-241' filepath='src/heap-profile-table.h' line='224' column='1' id='type-id-227'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef void (void*, const HeapProfileTable::AllocInfo&)* HeapProfileTable::AllocIterator -->
        <typedef-decl name='AllocIterator' type-id='type-id-243' filepath='src/heap-profile-table.h' line='138' column='1' id='type-id-242'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef void (const HeapProfileTable::AllocContextInfo&)* HeapProfileTable::AllocContextIterator -->
        <typedef-decl name='AllocContextIterator' type-id='type-id-245' filepath='src/heap-profile-table.h' line='147' column='1' id='type-id-244'/>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapProfileTable::BufferArgs -->
        <class-decl name='BufferArgs' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-profile-table.h' line='227' column='1' id='type-id-246'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- char* HeapProfileTable::BufferArgs::buf -->
            <var-decl name='buf' type-id='type-id-113' visibility='default' filepath='src/heap-profile-table.h' line='234' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- int HeapProfileTable::BufferArgs::buflen -->
            <var-decl name='buflen' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.h' line='235' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='96'>
            <!-- int HeapProfileTable::BufferArgs::bufsize -->
            <var-decl name='bufsize' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.h' line='236' column='1'/>
          </data-member>
          <member-function access='public' constructor='yes'>
            <!-- HeapProfileTable::BufferArgs::BufferArgs(char*, int, int) -->
            <function-decl name='BufferArgs' filepath='src/heap-profile-table.h' line='228' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::BufferArgs*' -->
              <parameter type-id='type-id-204' is-artificial='yes'/>
              <!-- parameter of type 'char*' -->
              <parameter type-id='type-id-113'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' constructor='yes'>
            <!-- HeapProfileTable::BufferArgs::BufferArgs(const HeapProfileTable::BufferArgs&) -->
            <function-decl name='BufferArgs' filepath='src/heap-profile-table.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::BufferArgs*' -->
              <parameter type-id='type-id-204' is-artificial='yes'/>
              <!-- parameter of type 'const HeapProfileTable::BufferArgs&' -->
              <parameter type-id='type-id-247'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void HeapProfileTable::BufferArgs::operator=(const HeapProfileTable::BufferArgs&) -->
            <function-decl name='operator=' mangled-name='_ZN16HeapProfileTable10BufferArgsaSERKS0_' filepath='src/heap-profile-table.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapProfileTable::BufferArgs*' -->
              <parameter type-id='type-id-204' is-artificial='yes'/>
              <!-- parameter of type 'const HeapProfileTable::BufferArgs&' -->
              <parameter type-id='type-id-247'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static char HeapProfileTable::kFileExt[] -->
        <var-decl name='kFileExt' type-id='type-id-148' mangled-name='_ZN16HeapProfileTable8kFileExtE' visibility='default' filepath='src/heap-profile-table.h' line='55' column='1' elf-symbol-id='_ZN16HeapProfileTable8kFileExtE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int HeapProfileTable::kMaxStackDepth -->
        <var-decl name='kMaxStackDepth' type-id='type-id-134' mangled-name='_ZN16HeapProfileTable14kMaxStackDepthE' visibility='default' filepath='src/heap-profile-table.h' line='58' column='1' elf-symbol-id='_ZN16HeapProfileTable14kMaxStackDepthE'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- HeapProfileTable::Allocator HeapProfileTable::alloc_ -->
        <var-decl name='alloc_' type-id='type-id-231' visibility='default' filepath='src/heap-profile-table.h' line='325' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- HeapProfileTable::DeAllocator HeapProfileTable::dealloc_ -->
        <var-decl name='dealloc_' type-id='type-id-232' visibility='default' filepath='src/heap-profile-table.h' line='326' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- HeapProfileTable::AllocValue::Bucket HeapProfileTable::total_ -->
        <var-decl name='total_' type-id='type-id-211' visibility='default' filepath='src/heap-profile-table.h' line='330' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='576'>
        <!-- bool HeapProfileTable::profile_mmap_ -->
        <var-decl name='profile_mmap_' type-id='type-id-55' visibility='default' filepath='src/heap-profile-table.h' line='332' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='640'>
        <!-- HeapProfileTable::AllocValue::Bucket** HeapProfileTable::bucket_table_ -->
        <var-decl name='bucket_table_' type-id='type-id-248' visibility='default' filepath='src/heap-profile-table.h' line='338' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='704'>
        <!-- int HeapProfileTable::num_buckets_ -->
        <var-decl name='num_buckets_' type-id='type-id-1' visibility='default' filepath='src/heap-profile-table.h' line='339' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='768'>
        <!-- HeapProfileTable::AllocationMap* HeapProfileTable::address_map_ -->
        <var-decl name='address_map_' type-id='type-id-249' visibility='default' filepath='src/heap-profile-table.h' line='342' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- HeapProfileTable::HeapProfileTable(HeapProfileTable::Allocator, HeapProfileTable::DeAllocator, bool) -->
        <function-decl name='HeapProfileTable' mangled-name='_ZN16HeapProfileTableC2EPFPvmEPFvS0_Eb' filepath='src/heap-profile-table.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTableC2EPFPvmEPFvS0_Eb'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'typedef HeapProfileTable::Allocator' -->
          <parameter type-id='type-id-231'/>
          <!-- parameter of type 'typedef HeapProfileTable::DeAllocator' -->
          <parameter type-id='type-id-232'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- HeapProfileTable::~HeapProfileTable(int) -->
        <function-decl name='~HeapProfileTable' mangled-name='_ZN16HeapProfileTableD1Ev' filepath='src/heap-profile-table.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTableD1Ev'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int HeapProfileTable::GetCallerStackTrace(void**) -->
        <function-decl name='GetCallerStackTrace' mangled-name='_ZN16HeapProfileTable19GetCallerStackTraceEiPPv' filepath='src/heap-profile-table.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable19GetCallerStackTraceEiPPv'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::RecordAlloc(void*, size_t, int, void* const*) -->
        <function-decl name='RecordAlloc' mangled-name='_ZN16HeapProfileTable11RecordAllocEPKvmiPKS1_' filepath='src/heap-profile-table.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable11RecordAllocEPKvmiPKS1_'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void* const*' -->
          <parameter type-id='type-id-173'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::RecordFree(void*) -->
        <function-decl name='RecordFree' mangled-name='_ZN16HeapProfileTable10RecordFreeEPKv' filepath='src/heap-profile-table.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable10RecordFreeEPKv'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapProfileTable::FindAlloc(void*, size_t*) -->
        <function-decl name='FindAlloc' mangled-name='_ZNK16HeapProfileTable9FindAllocEPKvPm' filepath='src/heap-profile-table.h' line='111' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable9FindAllocEPKvPm'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapProfileTable::FindAllocDetails(void*, HeapProfileTable::AllocInfo*) -->
        <function-decl name='FindAllocDetails' mangled-name='_ZNK16HeapProfileTable16FindAllocDetailsEPKvPNS_9AllocInfoE' filepath='src/heap-profile-table.h' line='113' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable16FindAllocDetailsEPKvPNS_9AllocInfoE'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocInfo*' -->
          <parameter type-id='type-id-253'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapProfileTable::FindInsideAlloc(void*, size_t, void**, size_t*) -->
        <function-decl name='FindInsideAlloc' mangled-name='_ZNK16HeapProfileTable15FindInsideAllocEPKvmPS1_Pm' filepath='src/heap-profile-table.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable15FindInsideAllocEPKvmPS1_Pm'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapProfileTable::MarkAsLive(void*) -->
        <function-decl name='MarkAsLive' mangled-name='_ZN16HeapProfileTable10MarkAsLiveEPKv' filepath='src/heap-profile-table.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable10MarkAsLiveEPKv'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::MarkAsIgnored(void*) -->
        <function-decl name='MarkAsIgnored' mangled-name='_ZN16HeapProfileTable13MarkAsIgnoredEPKv' filepath='src/heap-profile-table.h' line='130' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable13MarkAsIgnoredEPKv'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const HeapProfileTable::DumpArgs::Stats& HeapProfileTable::total() -->
        <function-decl name='total' mangled-name='_ZNK16HeapProfileTable5totalEv' filepath='src/heap-profile-table.h' line='134' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- const HeapProfileTable::DumpArgs::Stats& -->
          <return type-id='type-id-229'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::IterateAllocs(HeapProfileTable::AllocIterator) -->
        <function-decl name='IterateAllocs' mangled-name='_ZNK16HeapProfileTable13IterateAllocsEPFvPKvRKNS_9AllocInfoEE' filepath='src/heap-profile-table.h' line='142' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'typedef HeapProfileTable::AllocIterator' -->
          <parameter type-id='type-id-242'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::IterateOrderedAllocContexts(HeapProfileTable::AllocContextIterator) -->
        <function-decl name='IterateOrderedAllocContexts' mangled-name='_ZNK16HeapProfileTable27IterateOrderedAllocContextsEPFvRKNS_16AllocContextInfoEE' filepath='src/heap-profile-table.h' line='152' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable27IterateOrderedAllocContextsEPFvRKNS_16AllocContextInfoEE'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'typedef HeapProfileTable::AllocContextIterator' -->
          <parameter type-id='type-id-244'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- int HeapProfileTable::FillOrderedProfile(char*, int) -->
        <function-decl name='FillOrderedProfile' mangled-name='_ZNK16HeapProfileTable18FillOrderedProfileEPci' filepath='src/heap-profile-table.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable18FillOrderedProfileEPci'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::CleanupOldProfiles() -->
        <function-decl name='CleanupOldProfiles' mangled-name='_ZN16HeapProfileTable18CleanupOldProfilesEPKc' filepath='src/heap-profile-table.h' line='162' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable18CleanupOldProfilesEPKc'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- HeapProfileTable::Snapshot* HeapProfileTable::TakeSnapshot() -->
        <function-decl name='TakeSnapshot' mangled-name='_ZN16HeapProfileTable12TakeSnapshotEv' filepath='src/heap-profile-table.h' line='169' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable12TakeSnapshotEv'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- HeapProfileTable::Snapshot* -->
          <return type-id='type-id-230'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::ReleaseSnapshot(HeapProfileTable::Snapshot*) -->
        <function-decl name='ReleaseSnapshot' mangled-name='_ZN16HeapProfileTable15ReleaseSnapshotEPNS_8SnapshotE' filepath='src/heap-profile-table.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable15ReleaseSnapshotEPNS_8SnapshotE'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'HeapProfileTable::Snapshot*' -->
          <parameter type-id='type-id-230'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- HeapProfileTable::Snapshot* HeapProfileTable::NonLiveSnapshot(HeapProfileTable::Snapshot*) -->
        <function-decl name='NonLiveSnapshot' mangled-name='_ZN16HeapProfileTable15NonLiveSnapshotEPNS_8SnapshotE' filepath='src/heap-profile-table.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable15NonLiveSnapshotEPNS_8SnapshotE'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'HeapProfileTable::Snapshot*' -->
          <parameter type-id='type-id-230'/>
          <!-- HeapProfileTable::Snapshot* -->
          <return type-id='type-id-230'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- size_t HeapProfileTable::AllocValueSize() -->
        <function-decl name='AllocValueSize' mangled-name='_ZN16HeapProfileTable14AllocValueSizeERKNS_10AllocValueE' filepath='src/heap-profile-table.h' line='222' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable14AllocValueSizeERKNS_10AllocValueE'>
          <!-- parameter of type 'const HeapProfileTable::AllocValue&' -->
          <parameter type-id='type-id-233'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int HeapProfileTable::UnparseBucket(char*, int, int, const char*, HeapProfileTable::DumpArgs::Stats*) -->
        <function-decl name='UnparseBucket' mangled-name='_ZN16HeapProfileTable13UnparseBucketERK17HeapProfileBucketPciiPKcP16HeapProfileStats' filepath='src/heap-profile-table.h' line='265' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable13UnparseBucketERK17HeapProfileBucketPciiPKcP16HeapProfileStats'>
          <!-- parameter of type 'const HeapProfileTable::AllocValue::Bucket&' -->
          <parameter type-id='type-id-254'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'HeapProfileTable::DumpArgs::Stats*' -->
          <parameter type-id='type-id-218'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- HeapProfileTable::AllocValue::Bucket* HeapProfileTable::GetBucket(int, void* const*) -->
        <function-decl name='GetBucket' mangled-name='_ZN16HeapProfileTable9GetBucketEiPKPKv' filepath='src/heap-profile-table.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable9GetBucketEiPKPKv'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void* const*' -->
          <parameter type-id='type-id-173'/>
          <!-- HeapProfileTable::AllocValue::Bucket* -->
          <return type-id='type-id-214'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::MapArgsAllocIterator(HeapProfileTable::AllocValue*, HeapProfileTable::AllocIterator) -->
        <function-decl name='MapArgsAllocIterator' mangled-name='_ZN16HeapProfileTable20MapArgsAllocIteratorEPKvPNS_10AllocValueEPFvS1_RKNS_9AllocInfoEE' filepath='src/heap-profile-table.h' line='276' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable20MapArgsAllocIteratorEPKvPNS_10AllocValueEPFvS1_RKNS_9AllocInfoEE'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
          <parameter type-id='type-id-215'/>
          <!-- parameter of type 'typedef HeapProfileTable::AllocIterator' -->
          <parameter type-id='type-id-242'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::DumpBucketIterator(HeapProfileTable::BufferArgs*) -->
        <function-decl name='DumpBucketIterator' mangled-name='_ZN16HeapProfileTable18DumpBucketIteratorEPK17HeapProfileBucketPNS_10BufferArgsE' filepath='src/heap-profile-table.h' line='288' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable18DumpBucketIteratorEPK17HeapProfileBucketPNS_10BufferArgsE'>
          <!-- parameter of type 'const HeapProfileTable::AllocValue::Bucket*' -->
          <parameter type-id='type-id-255'/>
          <!-- parameter of type 'HeapProfileTable::BufferArgs*' -->
          <parameter type-id='type-id-204'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::DumpNonLiveIterator(HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&) -->
        <function-decl name='DumpNonLiveIterator' mangled-name='_ZN16HeapProfileTable19DumpNonLiveIteratorEPKvPNS_10AllocValueERKNS_8DumpArgsE' filepath='src/heap-profile-table.h' line='293' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable19DumpNonLiveIteratorEPKvPNS_10AllocValueERKNS_8DumpArgsE'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
          <parameter type-id='type-id-215'/>
          <!-- parameter of type 'const HeapProfileTable::DumpArgs&' -->
          <parameter type-id='type-id-256'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- HeapProfileTable::AllocValue::Bucket** HeapProfileTable::MakeSortedBucketList() -->
        <function-decl name='MakeSortedBucketList' mangled-name='_ZNK16HeapProfileTable20MakeSortedBucketListEv' filepath='src/heap-profile-table.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK16HeapProfileTable20MakeSortedBucketListEv'>
          <!-- implicit parameter of type 'const HeapProfileTable*' -->
          <parameter type-id='type-id-251' is-artificial='yes'/>
          <!-- HeapProfileTable::AllocValue::Bucket** -->
          <return type-id='type-id-248'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::AddToSnapshot(HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*) -->
        <function-decl name='AddToSnapshot' mangled-name='_ZN16HeapProfileTable13AddToSnapshotEPKvPNS_10AllocValueEPNS_8SnapshotE' filepath='src/heap-profile-table.h' line='302' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable13AddToSnapshotEPKvPNS_10AllocValueEPNS_8SnapshotE'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
          <parameter type-id='type-id-215'/>
          <!-- parameter of type 'HeapProfileTable::Snapshot*' -->
          <parameter type-id='type-id-230'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapProfileTable::AddIfNonLive(HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*) -->
        <function-decl name='AddIfNonLive' mangled-name='_ZN16HeapProfileTable12AddIfNonLiveEPKvPNS_10AllocValueEPNS_14AddNonLiveArgsE' filepath='src/heap-profile-table.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable12AddIfNonLiveEPKvPNS_10AllocValueEPNS_14AddNonLiveArgsE'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
          <parameter type-id='type-id-215'/>
          <!-- parameter of type 'HeapProfileTable::AddNonLiveArgs*' -->
          <parameter type-id='type-id-257'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool HeapProfileTable::WriteProfile(const HeapProfileTable::AllocValue::Bucket&, HeapProfileTable::AllocationMap*) -->
        <function-decl name='WriteProfile' mangled-name='_ZN16HeapProfileTable12WriteProfileEPKcRK17HeapProfileBucketP10AddressMapINS_10AllocValueEE' filepath='src/heap-profile-table.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16HeapProfileTable12WriteProfileEPKcRK17HeapProfileBucketP10AddressMapINS_10AllocValueEE'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'const HeapProfileTable::AllocValue::Bucket&' -->
          <parameter type-id='type-id-254'/>
          <!-- parameter of type 'HeapProfileTable::AllocationMap*' -->
          <parameter type-id='type-id-249'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- HeapProfileTable::HeapProfileTable(const HeapProfileTable&) -->
        <function-decl name='HeapProfileTable' filepath='src/heap-profile-table.h' line='344' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'const HeapProfileTable&' -->
          <parameter type-id='type-id-258'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapProfileTable::operator=(const HeapProfileTable&) -->
        <function-decl name='operator=' mangled-name='_ZN16HeapProfileTableaSERKS_' filepath='src/heap-profile-table.h' line='344' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapProfileTable*' -->
          <parameter type-id='type-id-250' is-artificial='yes'/>
          <!-- parameter of type 'const HeapProfileTable&' -->
          <parameter type-id='type-id-258'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class LowLevelAlloc -->
    <class-decl name='LowLevelAlloc' size-in-bits='8' visibility='default' filepath='src/base/low_level_alloc.h' line='44' column='1' id='type-id-81'>
      <member-type access='private'>
        <!-- struct LowLevelAlloc::Arena -->
        <class-decl name='Arena' size-in-bits='2560' is-struct='yes' visibility='default' filepath='src/base/low_level_alloc.cc' line='184' column='1' id='type-id-79'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- SpinLock LowLevelAlloc::Arena::mu -->
            <var-decl name='mu' type-id='type-id-82' visibility='default' filepath='src/base/low_level_alloc.cc' line='189' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- low_level_alloc_internal::AllocList LowLevelAlloc::Arena::freelist -->
            <var-decl name='freelist' type-id='type-id-75' visibility='default' filepath='src/base/low_level_alloc.cc' line='191' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2304'>
            <!-- int32 LowLevelAlloc::Arena::allocation_count -->
            <var-decl name='allocation_count' type-id='type-id-69' visibility='default' filepath='src/base/low_level_alloc.cc' line='192' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2336'>
            <!-- int32 LowLevelAlloc::Arena::flags -->
            <var-decl name='flags' type-id='type-id-69' visibility='default' filepath='src/base/low_level_alloc.cc' line='193' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2368'>
            <!-- size_t LowLevelAlloc::Arena::pagesize -->
            <var-decl name='pagesize' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='194' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2432'>
            <!-- size_t LowLevelAlloc::Arena::roundup -->
            <var-decl name='roundup' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='195' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='2496'>
            <!-- size_t LowLevelAlloc::Arena::min_size -->
            <var-decl name='min_size' type-id='type-id-57' visibility='default' filepath='src/base/low_level_alloc.cc' line='197' column='1'/>
          </data-member>
          <member-function access='public' constructor='yes'>
            <!-- LowLevelAlloc::Arena::Arena() -->
            <function-decl name='Arena' filepath='src/base/low_level_alloc.cc' line='185' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'LowLevelAlloc::Arena*' -->
              <parameter type-id='type-id-78' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' constructor='yes'>
            <!-- LowLevelAlloc::Arena::Arena(int) -->
            <function-decl name='Arena' filepath='src/base/low_level_alloc.cc' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'LowLevelAlloc::Arena*' -->
              <parameter type-id='type-id-78' is-artificial='yes'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-function access='private' static='yes'>
        <!-- void* LowLevelAlloc::Alloc() -->
        <function-decl name='Alloc' mangled-name='_ZN13LowLevelAlloc5AllocEm' filepath='./src/base/low_level_alloc.h' line='54' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc5AllocEm'>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void* LowLevelAlloc::AllocWithArena(LowLevelAlloc::Arena*) -->
        <function-decl name='AllocWithArena' mangled-name='_ZN13LowLevelAlloc14AllocWithArenaEmPNS_5ArenaE' filepath='./src/base/low_level_alloc.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc14AllocWithArenaEmPNS_5ArenaE'>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'LowLevelAlloc::Arena*' -->
          <parameter type-id='type-id-78'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void LowLevelAlloc::Free() -->
        <function-decl name='Free' mangled-name='_ZN13LowLevelAlloc4FreeEPv' filepath='./src/base/low_level_alloc.h' line='64' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc4FreeEPv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- LowLevelAlloc::Arena* LowLevelAlloc::NewArena(LowLevelAlloc::Arena*) -->
        <function-decl name='NewArena' mangled-name='_ZN13LowLevelAlloc8NewArenaEiPNS_5ArenaE' filepath='./src/base/low_level_alloc.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc8NewArenaEiPNS_5ArenaE'>
          <!-- parameter of type 'typedef int32' -->
          <parameter type-id='type-id-69'/>
          <!-- parameter of type 'LowLevelAlloc::Arena*' -->
          <parameter type-id='type-id-78'/>
          <!-- LowLevelAlloc::Arena* -->
          <return type-id='type-id-78'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool LowLevelAlloc::DeleteArena() -->
        <function-decl name='DeleteArena' mangled-name='_ZN13LowLevelAlloc11DeleteArenaEPNS_5ArenaE' filepath='./src/base/low_level_alloc.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc11DeleteArenaEPNS_5ArenaE'>
          <!-- parameter of type 'LowLevelAlloc::Arena*' -->
          <parameter type-id='type-id-78'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- LowLevelAlloc::Arena* LowLevelAlloc::DefaultArena() -->
        <function-decl name='DefaultArena' mangled-name='_ZN13LowLevelAlloc12DefaultArenaEv' filepath='./src/base/low_level_alloc.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13LowLevelAlloc12DefaultArenaEv'>
          <!-- LowLevelAlloc::Arena* -->
          <return type-id='type-id-78'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class HeapLeakChecker -->
    <class-decl name='HeapLeakChecker' size-in-bits='448' visibility='default' filepath='src/gperftools/heap-checker.h' line='78' column='1' id='type-id-259'>
      <member-type access='private'>
        <!-- class HeapLeakChecker::Disabler -->
        <class-decl name='Disabler' size-in-bits='8' visibility='default' filepath='./src/gperftools/heap-checker.h' line='175' column='1' id='type-id-260'>
          <member-function access='private' constructor='yes'>
            <!-- HeapLeakChecker::Disabler::Disabler() -->
            <function-decl name='Disabler' mangled-name='_ZN15HeapLeakChecker8DisablerC1Ev' filepath='./src/gperftools/heap-checker.h' line='177' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker8DisablerC1Ev'>
              <!-- implicit parameter of type 'HeapLeakChecker::Disabler*' -->
              <parameter type-id='type-id-261' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' destructor='yes'>
            <!-- HeapLeakChecker::Disabler::~Disabler(int) -->
            <function-decl name='~Disabler' mangled-name='_ZN15HeapLeakChecker8DisablerD1Ev' filepath='./src/gperftools/heap-checker.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker8DisablerD1Ev'>
              <!-- implicit parameter of type 'HeapLeakChecker::Disabler*' -->
              <parameter type-id='type-id-261' is-artificial='yes'/>
              <!-- artificial parameter of type 'int' -->
              <parameter type-id='type-id-1' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private' constructor='yes'>
            <!-- HeapLeakChecker::Disabler::Disabler(const HeapLeakChecker::Disabler&) -->
            <function-decl name='Disabler' filepath='./src/gperftools/heap-checker.h' line='180' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapLeakChecker::Disabler*' -->
              <parameter type-id='type-id-261' is-artificial='yes'/>
              <!-- parameter of type 'const HeapLeakChecker::Disabler&' -->
              <parameter type-id='type-id-262'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void HeapLeakChecker::Disabler::operator=(const HeapLeakChecker::Disabler&) -->
            <function-decl name='operator=' mangled-name='_ZN15HeapLeakChecker8DisableraSERKS0_' filepath='./src/gperftools/heap-checker.h' line='181' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'HeapLeakChecker::Disabler*' -->
              <parameter type-id='type-id-261' is-artificial='yes'/>
              <!-- parameter of type 'const HeapLeakChecker::Disabler&' -->
              <parameter type-id='type-id-262'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum HeapLeakChecker::ShouldSymbolize -->
        <enum-decl name='ShouldSymbolize' filepath='./src/gperftools/heap-checker.h' line='225' column='1' id='type-id-263'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='SYMBOLIZE' value='0'/>
          <enumerator name='DO_NOT_SYMBOLIZE' value='1'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum HeapLeakChecker::ProcMapsTask -->
        <enum-decl name='ProcMapsTask' filepath='./src/gperftools/heap-checker.h' line='295' column='1' id='type-id-264'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='RECORD_GLOBAL_DATA' value='0'/>
          <enumerator name='DISABLE_LIBRARY_ALLOCS' value='1'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum HeapLeakChecker::ProcMapsResult -->
        <enum-decl name='ProcMapsResult' filepath='./src/gperftools/heap-checker.h' line='301' column='1' id='type-id-265'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='PROC_MAPS_USED' value='0'/>
          <enumerator name='CANT_OPEN_PROC_MAPS' value='1'/>
          <enumerator name='NO_SHARED_LIBS_IN_PROC_MAPS' value='2'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapLeakChecker::RangeValue -->
        <class-decl name='RangeValue' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/heap-checker.cc' line='404' column='1' id='type-id-266'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- uintptr_t HeapLeakChecker::RangeValue::start_address -->
            <var-decl name='start_address' type-id='type-id-145' visibility='default' filepath='src/heap-checker.cc' line='405' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- int HeapLeakChecker::RangeValue::max_depth -->
            <var-decl name='max_depth' type-id='type-id-1' visibility='default' filepath='src/heap-checker.cc' line='406' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct HeapLeakChecker::Allocator -->
        <class-decl name='Allocator' size-in-bits='8' is-struct='yes' visibility='default' filepath='src/heap-checker.cc' line='292' column='1' id='type-id-267'>
          <data-member access='private' static='yes'>
            <!-- static LowLevelAlloc::Arena* HeapLeakChecker::Allocator::arena_ -->
            <var-decl name='arena_' type-id='type-id-78' mangled-name='_ZN15HeapLeakChecker9Allocator6arena_E' visibility='default' filepath='src/heap-checker.cc' line='333' column='1' elf-symbol-id='_ZN15HeapLeakChecker9Allocator6arena_E'/>
          </data-member>
          <data-member access='private' static='yes'>
            <!-- static int HeapLeakChecker::Allocator::alloc_count_ -->
            <var-decl name='alloc_count_' type-id='type-id-1' mangled-name='_ZN15HeapLeakChecker9Allocator12alloc_count_E' visibility='default' filepath='src/heap-checker.cc' line='334' column='1' elf-symbol-id='_ZN15HeapLeakChecker9Allocator12alloc_count_E'/>
          </data-member>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::Init() -->
            <function-decl name='Init' mangled-name='_ZN15HeapLeakChecker9Allocator4InitEv' filepath='src/heap-checker.cc' line='294' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::Shutdown() -->
            <function-decl name='Shutdown' mangled-name='_ZN15HeapLeakChecker9Allocator8ShutdownEv' filepath='src/heap-checker.cc' line='299' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- int HeapLeakChecker::Allocator::alloc_count() -->
            <function-decl name='alloc_count' mangled-name='_ZN15HeapLeakChecker9Allocator11alloc_countEv' filepath='src/heap-checker.cc' line='305' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void* HeapLeakChecker::Allocator::Allocate() -->
            <function-decl name='Allocate' mangled-name='_ZN15HeapLeakChecker9Allocator8AllocateEm' filepath='src/heap-checker.cc' line='309' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker9Allocator8AllocateEm'>
              <!-- parameter of type 'typedef size_t' -->
              <parameter type-id='type-id-57'/>
              <!-- void* -->
              <return type-id='type-id-53'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::Free() -->
            <function-decl name='Free' mangled-name='_ZN15HeapLeakChecker9Allocator4FreeEPv' filepath='src/heap-checker.cc' line='315' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker9Allocator4FreeEPv'>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::Free(size_t) -->
            <function-decl name='Free' mangled-name='_ZN15HeapLeakChecker9Allocator4FreeEPvm' filepath='src/heap-checker.cc' line='320' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'void*' -->
              <parameter type-id='type-id-53'/>
              <!-- parameter of type 'typedef size_t' -->
              <parameter type-id='type-id-57'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<DisabledRangeMap>() -->
            <function-decl name='DeleteAndNull&lt;DisabledRangeMap&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'DisabledRangeMap**' -->
              <parameter type-id='type-id-268'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<GlobalRegionCallerRangeMap>() -->
            <function-decl name='DeleteAndNull&lt;GlobalRegionCallerRangeMap&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'GlobalRegionCallerRangeMap**' -->
              <parameter type-id='type-id-269'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<HeapProfileTable>() -->
            <function-decl name='DeleteAndNull&lt;HeapProfileTable&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'HeapProfileTable**' -->
              <parameter type-id='type-id-270'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNullIfNot<DisabledRangeMap>() -->
            <function-decl name='DeleteAndNullIfNot&lt;DisabledRangeMap&gt;' filepath='src/heap-checker.cc' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'DisabledRangeMap**' -->
              <parameter type-id='type-id-268'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<LibraryLiveObjectsStacks>() -->
            <function-decl name='DeleteAndNull&lt;LibraryLiveObjectsStacks&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'LibraryLiveObjectsStacks**' -->
              <parameter type-id='type-id-271'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<LiveObjectsStack>() -->
            <function-decl name='DeleteAndNull&lt;LiveObjectsStack&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'LiveObjectsStack**' -->
              <parameter type-id='type-id-272'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNull<StackTopSet>() -->
            <function-decl name='DeleteAndNull&lt;StackTopSet&gt;' filepath='src/heap-checker.cc' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'StackTopSet**' -->
              <parameter type-id='type-id-273'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public' static='yes'>
            <!-- void HeapLeakChecker::Allocator::DeleteAndNullIfNot<GlobalRegionCallerRangeMap>() -->
            <function-decl name='DeleteAndNullIfNot&lt;GlobalRegionCallerRangeMap&gt;' filepath='src/heap-checker.cc' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- parameter of type 'GlobalRegionCallerRangeMap**' -->
              <parameter type-id='type-id-269'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- SpinLock* HeapLeakChecker::lock_ -->
        <var-decl name='lock_' type-id='type-id-89' visibility='default' filepath='./src/gperftools/heap-checker.h' line='358' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- const char* HeapLeakChecker::name_ -->
        <var-decl name='name_' type-id='type-id-52' visibility='default' filepath='./src/gperftools/heap-checker.h' line='359' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- void* HeapLeakChecker::start_snapshot_ -->
        <var-decl name='start_snapshot_' type-id='type-id-53' visibility='default' filepath='./src/gperftools/heap-checker.h' line='365' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- bool HeapLeakChecker::has_checked_ -->
        <var-decl name='has_checked_' type-id='type-id-55' visibility='default' filepath='./src/gperftools/heap-checker.h' line='367' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- ssize_t HeapLeakChecker::inuse_bytes_increase_ -->
        <var-decl name='inuse_bytes_increase_' type-id='type-id-274' visibility='default' filepath='./src/gperftools/heap-checker.h' line='368' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='320'>
        <!-- ssize_t HeapLeakChecker::inuse_allocs_increase_ -->
        <var-decl name='inuse_allocs_increase_' type-id='type-id-274' visibility='default' filepath='./src/gperftools/heap-checker.h' line='369' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='384'>
        <!-- bool HeapLeakChecker::keep_profiles_ -->
        <var-decl name='keep_profiles_' type-id='type-id-55' visibility='default' filepath='./src/gperftools/heap-checker.h' line='371' column='1'/>
      </data-member>
      <member-function access='private' static='yes'>
        <!-- bool HeapLeakChecker::IsActive() -->
        <function-decl name='IsActive' mangled-name='_ZN15HeapLeakChecker8IsActiveEv' filepath='./src/gperftools/heap-checker.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker8IsActiveEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- HeapLeakChecker* HeapLeakChecker::GlobalChecker() -->
        <function-decl name='GlobalChecker' mangled-name='_ZN15HeapLeakChecker13GlobalCheckerEv' filepath='./src/gperftools/heap-checker.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker13GlobalCheckerEv'>
          <!-- HeapLeakChecker* -->
          <return type-id='type-id-275'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool HeapLeakChecker::NoGlobalLeaks() -->
        <function-decl name='NoGlobalLeaks' mangled-name='_ZN15HeapLeakChecker13NoGlobalLeaksEv' filepath='./src/gperftools/heap-checker.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker13NoGlobalLeaksEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::CancelGlobalCheck() -->
        <function-decl name='CancelGlobalCheck' mangled-name='_ZN15HeapLeakChecker17CancelGlobalCheckEv' filepath='./src/gperftools/heap-checker.h' line='114' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker17CancelGlobalCheckEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- HeapLeakChecker::HeapLeakChecker(const char*) -->
        <function-decl name='HeapLeakChecker' mangled-name='_ZN15HeapLeakCheckerC1EPKc' filepath='./src/gperftools/heap-checker.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakCheckerC1EPKc'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- HeapLeakChecker::~HeapLeakChecker(int) -->
        <function-decl name='~HeapLeakChecker' mangled-name='_ZN15HeapLeakCheckerD1Ev' filepath='./src/gperftools/heap-checker.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakCheckerD1Ev'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::NoLeaks() -->
        <function-decl name='NoLeaks' mangled-name='_ZN15HeapLeakChecker7NoLeaksEv' filepath='./src/gperftools/heap-checker.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::QuickNoLeaks() -->
        <function-decl name='QuickNoLeaks' mangled-name='_ZN15HeapLeakChecker12QuickNoLeaksEv' filepath='./src/gperftools/heap-checker.h' line='141' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::BriefNoLeaks() -->
        <function-decl name='BriefNoLeaks' mangled-name='_ZN15HeapLeakChecker12BriefNoLeaksEv' filepath='./src/gperftools/heap-checker.h' line='142' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::SameHeap() -->
        <function-decl name='SameHeap' mangled-name='_ZN15HeapLeakChecker8SameHeapEv' filepath='./src/gperftools/heap-checker.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::QuickSameHeap() -->
        <function-decl name='QuickSameHeap' mangled-name='_ZN15HeapLeakChecker13QuickSameHeapEv' filepath='./src/gperftools/heap-checker.h' line='144' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::BriefSameHeap() -->
        <function-decl name='BriefSameHeap' mangled-name='_ZN15HeapLeakChecker13BriefSameHeapEv' filepath='./src/gperftools/heap-checker.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- ssize_t HeapLeakChecker::BytesLeaked() -->
        <function-decl name='BytesLeaked' mangled-name='_ZNK15HeapLeakChecker11BytesLeakedEv' filepath='./src/gperftools/heap-checker.h' line='155' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK15HeapLeakChecker11BytesLeakedEv'>
          <!-- implicit parameter of type 'const HeapLeakChecker*' -->
          <parameter type-id='type-id-276' is-artificial='yes'/>
          <!-- typedef ssize_t -->
          <return type-id='type-id-274'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- ssize_t HeapLeakChecker::ObjectsLeaked() -->
        <function-decl name='ObjectsLeaked' mangled-name='_ZNK15HeapLeakChecker13ObjectsLeakedEv' filepath='./src/gperftools/heap-checker.h' line='156' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK15HeapLeakChecker13ObjectsLeakedEv'>
          <!-- implicit parameter of type 'const HeapLeakChecker*' -->
          <parameter type-id='type-id-276' is-artificial='yes'/>
          <!-- typedef ssize_t -->
          <return type-id='type-id-274'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::UnIgnoreObject() -->
        <function-decl name='UnIgnoreObject' mangled-name='_ZN15HeapLeakChecker14UnIgnoreObjectEPKv' filepath='./src/gperftools/heap-checker.h' line='205' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker14UnIgnoreObjectEPKv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- char* HeapLeakChecker::MakeProfileNameLocked() -->
        <function-decl name='MakeProfileNameLocked' mangled-name='_ZN15HeapLeakChecker21MakeProfileNameLockedEv' filepath='./src/gperftools/heap-checker.h' line='220' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker21MakeProfileNameLockedEv'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- char* -->
          <return type-id='type-id-113'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapLeakChecker::Create(const char*, bool) -->
        <function-decl name='Create' mangled-name='_ZN15HeapLeakChecker6CreateEPKcb' filepath='./src/gperftools/heap-checker.h' line='223' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker6CreateEPKcb'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HeapLeakChecker::DoNoLeaks(HeapLeakChecker::ShouldSymbolize) -->
        <function-decl name='DoNoLeaks' mangled-name='_ZN15HeapLeakChecker9DoNoLeaksENS_15ShouldSymbolizeE' filepath='./src/gperftools/heap-checker.h' line='228' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker9DoNoLeaksENS_15ShouldSymbolizeE'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- parameter of type 'enum HeapLeakChecker::ShouldSymbolize' -->
          <parameter type-id='type-id-263'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool HeapLeakChecker::NoGlobalLeaksMaybeSymbolize() -->
        <function-decl name='NoGlobalLeaksMaybeSymbolize' mangled-name='_ZN15HeapLeakChecker27NoGlobalLeaksMaybeSymbolizeENS_15ShouldSymbolizeE' filepath='./src/gperftools/heap-checker.h' line='231' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker27NoGlobalLeaksMaybeSymbolizeENS_15ShouldSymbolizeE'>
          <!-- parameter of type 'enum HeapLeakChecker::ShouldSymbolize' -->
          <parameter type-id='type-id-263'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void* HeapLeakChecker::GetDisableChecksStart() -->
        <function-decl name='GetDisableChecksStart' mangled-name='_ZN15HeapLeakChecker21GetDisableChecksStartEv' filepath='./src/gperftools/heap-checker.h' line='236' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::DisableChecksToHereFrom() -->
        <function-decl name='DisableChecksToHereFrom' mangled-name='_ZN15HeapLeakChecker23DisableChecksToHereFromEPKv' filepath='./src/gperftools/heap-checker.h' line='237' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::DisableChecksIn() -->
        <function-decl name='DisableChecksIn' mangled-name='_ZN15HeapLeakChecker15DisableChecksInEPKc' filepath='./src/gperftools/heap-checker.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker15DisableChecksInEPKc'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::DoIgnoreObject() -->
        <function-decl name='DoIgnoreObject' mangled-name='_ZN15HeapLeakChecker14DoIgnoreObjectEPKv' filepath='./src/gperftools/heap-checker.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker14DoIgnoreObjectEPKv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::DisableChecksFromToLocked(void*, int) -->
        <function-decl name='DisableChecksFromToLocked' mangled-name='_ZN15HeapLeakChecker25DisableChecksFromToLockedEPKvS1_i' filepath='./src/gperftools/heap-checker.h' line='250' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker25DisableChecksFromToLockedEPKvS1_i'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::IgnoreAllLiveObjectsLocked() -->
        <function-decl name='IgnoreAllLiveObjectsLocked' mangled-name='_ZN15HeapLeakChecker26IgnoreAllLiveObjectsLockedEPKv' filepath='./src/gperftools/heap-checker.h' line='255' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker26IgnoreAllLiveObjectsLockedEPKv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int HeapLeakChecker::IgnoreLiveThreadsLocked(int, pid_t*, typedef __va_list_tag __va_list_tag*) -->
        <function-decl name='IgnoreLiveThreadsLocked' mangled-name='_ZN15HeapLeakChecker23IgnoreLiveThreadsLockedEPviPiP13__va_list_tag' filepath='./src/gperftools/heap-checker.h' line='268' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker23IgnoreLiveThreadsLockedEPviPiP13__va_list_tag'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'pid_t*' -->
          <parameter type-id='type-id-66'/>
          <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
          <parameter type-id='type-id-67'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::IgnoreNonThreadLiveObjectsLocked() -->
        <function-decl name='IgnoreNonThreadLiveObjectsLocked' mangled-name='_ZN15HeapLeakChecker32IgnoreNonThreadLiveObjectsLockedEv' filepath='./src/gperftools/heap-checker.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker32IgnoreNonThreadLiveObjectsLockedEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::IgnoreLiveObjectsLocked(const char*) -->
        <function-decl name='IgnoreLiveObjectsLocked' mangled-name='_ZN15HeapLeakChecker23IgnoreLiveObjectsLockedEPKcS1_' filepath='./src/gperftools/heap-checker.h' line='288' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker23IgnoreLiveObjectsLockedEPKcS1_'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool HeapLeakChecker::DoMainHeapCheck() -->
        <function-decl name='DoMainHeapCheck' mangled-name='_ZN15HeapLeakChecker15DoMainHeapCheckEv' filepath='./src/gperftools/heap-checker.h' line='292' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker15DoMainHeapCheckEv'>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- HeapLeakChecker::ProcMapsResult HeapLeakChecker::UseProcMapsLocked() -->
        <function-decl name='UseProcMapsLocked' mangled-name='_ZN15HeapLeakChecker17UseProcMapsLockedENS_12ProcMapsTaskE' filepath='./src/gperftools/heap-checker.h' line='308' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker17UseProcMapsLockedENS_12ProcMapsTaskE'>
          <!-- parameter of type 'enum HeapLeakChecker::ProcMapsTask' -->
          <parameter type-id='type-id-264'/>
          <!-- enum HeapLeakChecker::ProcMapsResult -->
          <return type-id='type-id-265'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::DisableLibraryAllocsLocked(uintptr_t, uintptr_t) -->
        <function-decl name='DisableLibraryAllocsLocked' mangled-name='_ZN15HeapLeakChecker26DisableLibraryAllocsLockedEPKcmm' filepath='./src/gperftools/heap-checker.h' line='313' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker26DisableLibraryAllocsLockedEPKcmm'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef uintptr_t' -->
          <parameter type-id='type-id-145'/>
          <!-- parameter of type 'typedef uintptr_t' -->
          <parameter type-id='type-id-145'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool HeapLeakChecker::HaveOnHeapLocked(size_t*) -->
        <function-decl name='HaveOnHeapLocked' mangled-name='_ZN15HeapLeakChecker16HaveOnHeapLockedEPPKvPm' filepath='./src/gperftools/heap-checker.h' line='323' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::TurnItselfOffLocked() -->
        <function-decl name='TurnItselfOffLocked' mangled-name='_ZN15HeapLeakChecker19TurnItselfOffLockedEv' filepath='./src/gperftools/heap-checker.h' line='327' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker19TurnItselfOffLockedEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- HeapLeakChecker::HeapLeakChecker() -->
        <function-decl name='HeapLeakChecker' mangled-name='_ZN15HeapLeakCheckerC1Ev' filepath='./src/gperftools/heap-checker.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakCheckerC1Ev'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void* HeapLeakChecker::GetAllocCaller() -->
        <function-decl name='GetAllocCaller' mangled-name='_ZN15HeapLeakChecker14GetAllocCallerEPv' filepath='./src/gperftools/heap-checker.h' line='338' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker14GetAllocCallerEPv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapLeakChecker::BeforeConstructorsLocked() -->
        <function-decl name='BeforeConstructorsLocked' mangled-name='_ZN15HeapLeakChecker24BeforeConstructorsLockedEv' filepath='./src/gperftools/heap-checker.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15HeapLeakChecker24BeforeConstructorsLockedEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- HeapLeakChecker::HeapLeakChecker(const HeapLeakChecker&) -->
        <function-decl name='HeapLeakChecker' filepath='./src/gperftools/heap-checker.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- parameter of type 'const HeapLeakChecker&' -->
          <parameter type-id='type-id-277'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void HeapLeakChecker::operator=(const HeapLeakChecker&) -->
        <function-decl name='operator=' mangled-name='_ZN15HeapLeakCheckeraSERKS_' filepath='./src/gperftools/heap-checker.h' line='377' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HeapLeakChecker*' -->
          <parameter type-id='type-id-275' is-artificial='yes'/>
          <!-- parameter of type 'const HeapLeakChecker&' -->
          <parameter type-id='type-id-277'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- char* HeapLeakChecker::IgnoreObject<char>() -->
        <function-decl name='IgnoreObject&lt;char&gt;' filepath='./src/gperftools/heap-checker.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- char* -->
          <return type-id='type-id-113'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocExtension* HeapLeakChecker::IgnoreObject<MallocExtension>() -->
        <function-decl name='IgnoreObject&lt;MallocExtension&gt;' filepath='src/gperftools/heap-checker.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278'/>
          <!-- MallocExtension* -->
          <return type-id='type-id-278'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class AddressMap<HeapProfileTable::AllocValue> -->
    <class-decl name='AddressMap&lt;HeapProfileTable::AllocValue&gt;' size-in-bits='320' visibility='default' filepath='src/addressmap-inl.h' line='104' column='1' id='type-id-241'>
      <member-type access='private'>
        <!-- struct AddressMap<HeapProfileTable::AllocValue>::Cluster -->
        <class-decl name='Cluster' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-279'/>
      </member-type>
      <member-type access='private'>
        <!-- struct AddressMap<HeapProfileTable::AllocValue>::Entry -->
        <class-decl name='Entry' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-280'/>
      </member-type>
      <member-type access='private'>
        <!-- struct AddressMap<HeapProfileTable::AllocValue>::Object -->
        <class-decl name='Object' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-281'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kBlockBits -->
        <var-decl name='kBlockBits' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='159' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kBlockSize -->
        <var-decl name='kBlockSize' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='160' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kClusterBits -->
        <var-decl name='kClusterBits' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='172' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const uintptr_t AddressMap<HeapProfileTable::AllocValue>::kClusterSize -->
        <var-decl name='kClusterSize' type-id='type-id-282' visibility='default' filepath='src/addressmap-inl.h' line='173' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kClusterBlocks -->
        <var-decl name='kClusterBlocks' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='174' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kHashBits -->
        <var-decl name='kHashBits' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='187' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::kHashSize -->
        <var-decl name='kHashSize' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='188' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int AddressMap<HeapProfileTable::AllocValue>::ALLOC_COUNT -->
        <var-decl name='ALLOC_COUNT' type-id='type-id-134' visibility='default' filepath='src/addressmap-inl.h' line='191' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster** AddressMap<HeapProfileTable::AllocValue>::hashtable_ -->
        <var-decl name='hashtable_' type-id='type-id-283' visibility='default' filepath='src/addressmap-inl.h' line='193' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Entry* AddressMap<HeapProfileTable::AllocValue>::free_ -->
        <var-decl name='free_' type-id='type-id-284' visibility='default' filepath='src/addressmap-inl.h' line='194' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const uint32_t AddressMap<HeapProfileTable::AllocValue>::kHashMultiplier -->
        <var-decl name='kHashMultiplier' type-id='type-id-285' visibility='default' filepath='src/addressmap-inl.h' line='202' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- void* (unsigned long int)* AddressMap<HeapProfileTable::AllocValue>::alloc_ -->
        <var-decl name='alloc_' type-id='type-id-286' visibility='default' filepath='src/addressmap-inl.h' line='251' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- void (void*)* AddressMap<HeapProfileTable::AllocValue>::dealloc_ -->
        <var-decl name='dealloc_' type-id='type-id-240' visibility='default' filepath='src/addressmap-inl.h' line='252' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Object* AddressMap<HeapProfileTable::AllocValue>::allocated_ -->
        <var-decl name='allocated_' type-id='type-id-287' visibility='default' filepath='src/addressmap-inl.h' line='253' column='1'/>
      </data-member>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::AddressMap(void* (unsigned long int)*, void (void*)*) -->
        <function-decl name='AddressMap' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEEC2EPFPvmEPFvS3_E' filepath='src/addressmap-inl.h' line='271' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10AddressMapIN16HeapProfileTable10AllocValueEEC2EPFPvmEPFvS3_E'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'void* (unsigned long int)*' -->
          <parameter type-id='type-id-286'/>
          <!-- parameter of type 'void (void*)*' -->
          <parameter type-id='type-id-240'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::~AddressMap(int) -->
        <function-decl name='~AddressMap' filepath='src/addressmap-inl.h' line='280' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const HeapProfileTable::AllocValue* AddressMap<HeapProfileTable::AllocValue>::Find(void*) -->
        <function-decl name='Find' mangled-name='_ZNK10AddressMapIN16HeapProfileTable10AllocValueEE4FindEPKv' filepath='src/addressmap-inl.h' line='290' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- const HeapProfileTable::AllocValue* -->
          <return type-id='type-id-213'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- HeapProfileTable::AllocValue* AddressMap<HeapProfileTable::AllocValue>::FindMutable(void*) -->
        <function-decl name='FindMutable' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE11FindMutableEPKv' filepath='src/addressmap-inl.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- HeapProfileTable::AllocValue* -->
          <return type-id='type-id-215'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Insert(void*, HeapProfileTable::AllocValue) -->
        <function-decl name='Insert' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE6InsertEPKvS1_' filepath='src/addressmap-inl.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE6InsertEPKvS1_'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'struct HeapProfileTable::AllocValue' -->
          <parameter type-id='type-id-210'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool AddressMap<HeapProfileTable::AllocValue>::FindAndRemove(void*, HeapProfileTable::AllocValue*) -->
        <function-decl name='FindAndRemove' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE13FindAndRemoveEPKvPS1_' filepath='src/addressmap-inl.h' line='341' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
          <parameter type-id='type-id-215'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const HeapProfileTable::AllocValue* AddressMap<HeapProfileTable::AllocValue>::FindInside(typedef size_t (const HeapProfileTable::AllocValue&)*, unsigned long int, void*, void**) -->
        <function-decl name='FindInside' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE10FindInsideEPFmRKS1_EmPKvPS8_' filepath='src/addressmap-inl.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t (const HeapProfileTable::AllocValue&)*' -->
          <parameter type-id='type-id-290'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- const HeapProfileTable::AllocValue* -->
          <return type-id='type-id-213'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int AddressMap<HeapProfileTable::AllocValue>::HashInt() -->
        <function-decl name='HashInt' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE7HashIntEm' filepath='src/addressmap-inl.h' line='203' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster* AddressMap<HeapProfileTable::AllocValue>::FindCluster(unsigned long int, bool) -->
        <function-decl name='FindCluster' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE11FindClusterEmb' filepath='src/addressmap-inl.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster* -->
          <return type-id='type-id-291'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int AddressMap<HeapProfileTable::AllocValue>::BlockID() -->
        <function-decl name='BlockID' mangled-name='_ZN10AddressMapIN16HeapProfileTable10AllocValueEE7BlockIDEm' filepath='src/addressmap-inl.h' line='236' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<void (*)(const void*, const HeapProfileTable::AllocInfo&)>(void (void*, HeapProfileTable::AllocValue*, void (void*, const HeapProfileTable::AllocInfo&)*)*, void (void*, const HeapProfileTable::AllocInfo&)*) -->
        <function-decl name='Iterate&lt;void (*)(const void*, const HeapProfileTable::AllocInfo&amp;)&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, void (void*, const HeapProfileTable::AllocInfo&)*)*' -->
          <parameter type-id='type-id-292'/>
          <!-- parameter of type 'void (void*, const HeapProfileTable::AllocInfo&)*' -->
          <parameter type-id='type-id-243'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<char*>(void (void*, HeapProfileTable::AllocValue*, char*)*, char*) -->
        <function-decl name='Iterate&lt;char*&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, char*)*' -->
          <parameter type-id='type-id-293'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster** AddressMap<HeapProfileTable::AllocValue>::New<AddressMap<HeapProfileTable::AllocValue>::Cluster*>(int) -->
        <function-decl name='New&lt;AddressMap&lt;HeapProfileTable::AllocValue&gt;::Cluster*&gt;' filepath='src/addressmap-inl.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster** -->
          <return type-id='type-id-283'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<HeapProfileTable::AddNonLiveArgs*>(void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*)*, HeapProfileTable::AddNonLiveArgs*) -->
        <function-decl name='Iterate&lt;HeapProfileTable::AddNonLiveArgs*&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*)*' -->
          <parameter type-id='type-id-294'/>
          <!-- parameter of type 'HeapProfileTable::AddNonLiveArgs*' -->
          <parameter type-id='type-id-257'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<HeapProfileTable::Snapshot*>(void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*)*, HeapProfileTable::Snapshot*) -->
        <function-decl name='Iterate&lt;HeapProfileTable::Snapshot*&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*)*' -->
          <parameter type-id='type-id-295'/>
          <!-- parameter of type 'HeapProfileTable::Snapshot*' -->
          <parameter type-id='type-id-230'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster* AddressMap<HeapProfileTable::AllocValue>::New<AddressMap<HeapProfileTable::AllocValue>::Cluster>(int) -->
        <function-decl name='New&lt;AddressMap&lt;HeapProfileTable::AllocValue&gt;::Cluster&gt;' filepath='src/addressmap-inl.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster* -->
          <return type-id='type-id-291'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- AddressMap<HeapProfileTable::AllocValue>::Entry* AddressMap<HeapProfileTable::AllocValue>::New<AddressMap<HeapProfileTable::AllocValue>::Entry>(int) -->
        <function-decl name='New&lt;AddressMap&lt;HeapProfileTable::AllocValue&gt;::Entry&gt;' filepath='src/addressmap-inl.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-288' is-artificial='yes'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- AddressMap<HeapProfileTable::AllocValue>::Entry* -->
          <return type-id='type-id-284'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<const HeapProfileTable::DumpArgs&>(void (void*, HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&)*, const HeapProfileTable::DumpArgs&) -->
        <function-decl name='Iterate&lt;const HeapProfileTable::DumpArgs&amp;&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&)*' -->
          <parameter type-id='type-id-296'/>
          <!-- parameter of type 'const HeapProfileTable::DumpArgs&' -->
          <parameter type-id='type-id-256'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void AddressMap<HeapProfileTable::AllocValue>::Iterate<HeapProfileTable::Snapshot::ReportState*>(void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*)*, HeapProfileTable::Snapshot::ReportState*) -->
        <function-decl name='Iterate&lt;HeapProfileTable::Snapshot::ReportState*&gt;' filepath='src/addressmap-inl.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const AddressMap<HeapProfileTable::AllocValue>*' -->
          <parameter type-id='type-id-289' is-artificial='yes'/>
          <!-- parameter of type 'void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*)*' -->
          <parameter type-id='type-id-297'/>
          <!-- parameter of type 'HeapProfileTable::Snapshot::ReportState*' -->
          <parameter type-id='type-id-234'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<char, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-298'>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-300'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<char, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- char* STL_Allocator<char, HeapLeakChecker::Allocator>::address(char&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE7addressERc' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-301' is-artificial='yes'/>
          <!-- parameter of type 'char&' -->
          <parameter type-id='type-id-302'/>
          <!-- char* -->
          <return type-id='type-id-113'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const char* STL_Allocator<char, HeapLeakChecker::Allocator>::address(const char&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE7addressERKc' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-301' is-artificial='yes'/>
          <!-- parameter of type 'const char&' -->
          <parameter type-id='type-id-303'/>
          <!-- const char* -->
          <return type-id='type-id-52'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- char* STL_Allocator<char, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- char* -->
          <return type-id='type-id-113'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::deallocate(char*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE10deallocateEPcm' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<char, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-301' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::construct(char*, const char&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE9constructEPcRKc' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'const char&' -->
          <parameter type-id='type-id-303'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::construct(char*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE9constructEPc' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<char, HeapLeakChecker::Allocator>::destroy(char*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorIcN15HeapLeakChecker9AllocatorEE7destroyEPc' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-299' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<char, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEeqERKS2_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-301' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-300'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct HeapProfileBucket -->
    <class-decl name='HeapProfileBucket' size-in-bits='448' is-struct='yes' visibility='default' filepath='src/heap-profile-stats.h' line='68' column='1' id='type-id-212'>
      <!-- struct HeapProfileStats -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-164'/>
      <data-member access='public' static='yes'>
        <!-- static const int HeapProfileBucket::kMaxStackDepth -->
        <var-decl name='kMaxStackDepth' type-id='type-id-134' visibility='default' filepath='src/heap-profile-stats.h' line='70' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- uintptr_t HeapProfileBucket::hash -->
        <var-decl name='hash' type-id='type-id-145' visibility='default' filepath='src/heap-profile-stats.h' line='72' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- int HeapProfileBucket::depth -->
        <var-decl name='depth' type-id='type-id-1' visibility='default' filepath='src/heap-profile-stats.h' line='73' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- void** HeapProfileBucket::stack -->
        <var-decl name='stack' type-id='type-id-141' visibility='default' filepath='src/heap-profile-stats.h' line='74' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- HeapProfileBucket* HeapProfileBucket::next -->
        <var-decl name='next' type-id='type-id-205' visibility='default' filepath='src/heap-profile-stats.h' line='75' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef int RawFD -->
    <typedef-decl name='RawFD' type-id='type-id-1' filepath='./src/base/logging.h' line='251' column='1' id='type-id-70'/>
    <!-- typedef long int __intptr_t -->
    <typedef-decl name='__intptr_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='189' column='1' id='type-id-304'/>
    <!-- typedef __off_t off_t -->
    <typedef-decl name='off_t' type-id='type-id-305' filepath='/usr/include/sys/types.h' line='87' column='1' id='type-id-207'/>
    <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-306'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-308'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::address(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E7addressERSE_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-309' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
          <parameter type-id='type-id-310'/>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
          <return type-id='type-id-311'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::address(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E7addressERKSE_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-309' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
          <parameter type-id='type-id-312'/>
          <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
          <return type-id='type-id-313'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
          <return type-id='type-id-311'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::deallocate(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E10deallocateEPSE_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
          <parameter type-id='type-id-311'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-309' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E9constructEPSE_RKSE_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
          <parameter type-id='type-id-311'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
          <parameter type-id='type-id-312'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E9constructEPSE_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
          <parameter type-id='type-id-311'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::destroy(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_E7destroyEPSE_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-307' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
          <parameter type-id='type-id-311'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_ISA_S5_EEEES5_EeqERKSF_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-309' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-308'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-314'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-316'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::address(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E7addressERSC_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-317' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
          <parameter type-id='type-id-318'/>
          <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
          <return type-id='type-id-319'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::address(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E7addressERKSC_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-317' is-artificial='yes'/>
          <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
          <parameter type-id='type-id-320'/>
          <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
          <return type-id='type-id-321'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
          <return type-id='type-id-319'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::deallocate(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E10deallocateEPSC_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
          <parameter type-id='type-id-319'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-317' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::construct(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E9constructEPSC_RKSC_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
          <parameter type-id='type-id-319'/>
          <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
          <parameter type-id='type-id-320'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::construct(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E9constructEPSC_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
          <parameter type-id='type-id-319'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::destroy(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_E7destroyEPSC_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
          <parameter type-id='type-id-319'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt4pairIKSbIcSt11char_traitsIcES_IcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS_IS9_S4_EEES4_EeqERKSD_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-317' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-316'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>::STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > >(const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-315' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-308'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-322'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-324'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::address(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE7addressERS6_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-325' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
          <parameter type-id='type-id-326'/>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
          <return type-id='type-id-327'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::address(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE7addressERKS6_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-325' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
          <parameter type-id='type-id-328'/>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
          <return type-id='type-id-329'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
          <return type-id='type-id-327'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::deallocate(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE10deallocateEPS6_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
          <parameter type-id='type-id-327'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-325' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE9constructEPS6_RKS6_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
          <parameter type-id='type-id-327'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
          <parameter type-id='type-id-328'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE9constructEPS6_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
          <parameter type-id='type-id-327'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::destroy(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEE7destroyEPS6_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-323' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
          <parameter type-id='type-id-327'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmN15HeapLeakChecker10RangeValueEEENS3_9AllocatorEEeqERKS8_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-325' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-324'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-330'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-332'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::address(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE7addressERS4_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-333' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
          <parameter type-id='type-id-334'/>
          <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
          <return type-id='type-id-335'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::address(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE7addressERKS4_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-333' is-artificial='yes'/>
          <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
          <parameter type-id='type-id-336'/>
          <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
          <return type-id='type-id-337'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
          <return type-id='type-id-335'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::deallocate(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE10deallocateEPS4_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
          <parameter type-id='type-id-335'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-333' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::construct(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE9constructEPS4_RKS4_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
          <parameter type-id='type-id-335'/>
          <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
          <parameter type-id='type-id-336'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::construct(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE9constructEPS4_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
          <parameter type-id='type-id-335'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::destroy(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEE7destroyEPS4_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
          <parameter type-id='type-id-335'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt4pairIKmN15HeapLeakChecker10RangeValueEENS2_9AllocatorEEeqERKS6_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-333' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-332'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>::STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > >(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-331' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-324'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;long unsigned int&gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-338'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-340'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<long unsigned int>* STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::address(std::_Rb_tree_node<long unsigned int>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE7addressERS1_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-341' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>&' -->
          <parameter type-id='type-id-342'/>
          <!-- std::_Rb_tree_node<long unsigned int>* -->
          <return type-id='type-id-343'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<long unsigned int>* STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::address(const std::_Rb_tree_node<long unsigned int>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE7addressERKS1_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-341' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>&' -->
          <parameter type-id='type-id-344'/>
          <!-- const std::_Rb_tree_node<long unsigned int>* -->
          <return type-id='type-id-345'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<long unsigned int>* STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<long unsigned int>* -->
          <return type-id='type-id-343'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::deallocate(std::_Rb_tree_node<long unsigned int>*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE10deallocateEPS1_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
          <parameter type-id='type-id-343'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-341' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<long unsigned int>*, const std::_Rb_tree_node<long unsigned int>&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE9constructEPS1_RKS1_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
          <parameter type-id='type-id-343'/>
          <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>&' -->
          <parameter type-id='type-id-344'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<long unsigned int>*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE9constructEPS1_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
          <parameter type-id='type-id-343'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::destroy(std::_Rb_tree_node<long unsigned int>*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEE7destroyEPS1_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-339' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
          <parameter type-id='type-id-343'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeImEN15HeapLeakChecker9AllocatorEEeqERKS4_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-341' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-340'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;long unsigned int, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-346'>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-348'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- unsigned long int* STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::address(unsigned long int&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorImN15HeapLeakChecker9AllocatorEE7addressERm' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-349' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int&' -->
          <parameter type-id='type-id-350'/>
          <!-- unsigned long int* -->
          <return type-id='type-id-351'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const unsigned long int* STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::address(const unsigned long int&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorImN15HeapLeakChecker9AllocatorEE7addressERKm' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-349' is-artificial='yes'/>
          <!-- parameter of type 'const unsigned long int&' -->
          <parameter type-id='type-id-352'/>
          <!-- const unsigned long int* -->
          <return type-id='type-id-353'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- unsigned long int* STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorImN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- unsigned long int* -->
          <return type-id='type-id-351'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::deallocate(unsigned long int*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorImN15HeapLeakChecker9AllocatorEE10deallocateEPmm' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int*' -->
          <parameter type-id='type-id-351'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorImN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-349' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::construct(unsigned long int*, const unsigned long int&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorImN15HeapLeakChecker9AllocatorEE9constructEPmRKm' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int*' -->
          <parameter type-id='type-id-351'/>
          <!-- parameter of type 'const unsigned long int&' -->
          <parameter type-id='type-id-352'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::construct(unsigned long int*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorImN15HeapLeakChecker9AllocatorEE9constructEPm' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int*' -->
          <parameter type-id='type-id-351'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::destroy(unsigned long int*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorImN15HeapLeakChecker9AllocatorEE7destroyEPm' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int*' -->
          <parameter type-id='type-id-351'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorImN15HeapLeakChecker9AllocatorEEeqERKS2_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-349' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-348'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>::STL_Allocator<std::_Rb_tree_node<long unsigned int> >(const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;long unsigned int&gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-347' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-340'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-354'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-356'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::address(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE7addressERS4_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-357' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&' -->
          <parameter type-id='type-id-358'/>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
          <return type-id='type-id-359'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::address(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE7addressERKS4_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-357' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&' -->
          <parameter type-id='type-id-360'/>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
          <return type-id='type-id-361'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
          <return type-id='type-id-359'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::deallocate(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE10deallocateEPS4_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
          <parameter type-id='type-id-359'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-357' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE9constructEPS4_RKS4_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
          <parameter type-id='type-id-359'/>
          <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >&' -->
          <parameter type-id='type-id-360'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::construct(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE9constructEPS4_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
          <parameter type-id='type-id-359'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::destroy(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEE7destroyEPS4_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-355' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
          <parameter type-id='type-id-359'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeISt4pairIKmmEEN15HeapLeakChecker9AllocatorEEeqERKS7_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-357' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-356'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> -->
    <class-decl name='STL_Allocator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt;, HeapLeakChecker::Allocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-362'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::STL_Allocator(const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-364'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const long unsigned int, long unsigned int>* STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::address(std::pair<const long unsigned int, long unsigned int>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE7addressERS2_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-365' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>&' -->
          <parameter type-id='type-id-366'/>
          <!-- std::pair<const long unsigned int, long unsigned int>* -->
          <return type-id='type-id-367'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::pair<const long unsigned int, long unsigned int>* STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::address(const std::pair<const long unsigned int, long unsigned int>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE7addressERKS2_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-365' is-artificial='yes'/>
          <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
          <parameter type-id='type-id-368'/>
          <!-- const std::pair<const long unsigned int, long unsigned int>* -->
          <return type-id='type-id-369'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::pair<const long unsigned int, long unsigned int>* STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::pair<const long unsigned int, long unsigned int>* -->
          <return type-id='type-id-367'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::deallocate(std::pair<const long unsigned int, long unsigned int>*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE10deallocateEPS2_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
          <parameter type-id='type-id-367'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-365' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::construct(std::pair<const long unsigned int, long unsigned int>*, const std::pair<const long unsigned int, long unsigned int>&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE9constructEPS2_RKS2_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
          <parameter type-id='type-id-367'/>
          <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
          <parameter type-id='type-id-368'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::construct(std::pair<const long unsigned int, long unsigned int>*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE9constructEPS2_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
          <parameter type-id='type-id-367'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::destroy(std::pair<const long unsigned int, long unsigned int>*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEE7destroyEPS2_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
          <parameter type-id='type-id-367'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::operator==(const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEeqERKS5_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-365' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-364'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>::STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> > >(const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>*' -->
          <parameter type-id='type-id-363' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&' -->
          <parameter type-id='type-id-356'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef int _Atomic_word -->
    <typedef-decl name='_Atomic_word' type-id='type-id-1' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/x86_64-redhat-linux/bits/atomic_word.h' line='32' column='1' id='type-id-370'/>
    <!-- typedef std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > DisabledRangeMap -->
    <typedef-decl name='DisabledRangeMap' type-id='type-id-371' filepath='src/heap-checker.cc' line='411' column='1' id='type-id-372'/>
    <!-- typedef std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > GlobalRegionCallerRangeMap -->
    <typedef-decl name='GlobalRegionCallerRangeMap' type-id='type-id-373' filepath='src/heap-checker.cc' line='432' column='1' id='type-id-374'/>
    <!-- typedef std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > LibraryLiveObjectsStacks -->
    <typedef-decl name='LibraryLiveObjectsStacks' type-id='type-id-375' filepath='src/heap-checker.cc' line='397' column='1' id='type-id-376'/>
    <!-- typedef std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > LiveObjectsStack -->
    <typedef-decl name='LiveObjectsStack' type-id='type-id-377' filepath='src/heap-checker.cc' line='384' column='1' id='type-id-378'/>
    <!-- typedef std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > StackTopSet -->
    <typedef-decl name='StackTopSet' type-id='type-id-379' filepath='src/heap-checker.cc' line='422' column='1' id='type-id-380'/>
    <!-- typedef void (void*, typedef size_t)* MallocHook_NewHook -->
    <typedef-decl name='MallocHook_NewHook' type-id='type-id-381' filepath='./src/gperftools/malloc_hook_c.h' line='70' column='1' id='type-id-382'/>
    <!-- typedef void (void*)* MallocHook_DeleteHook -->
    <typedef-decl name='MallocHook_DeleteHook' type-id='type-id-240' filepath='./src/gperftools/malloc_hook_c.h' line='76' column='1' id='type-id-383'/>
    <!-- typedef void (void*, void*, typedef size_t, int, int, int, typedef off_t)* MallocHook_MmapHook -->
    <typedef-decl name='MallocHook_MmapHook' type-id='type-id-384' filepath='./src/gperftools/malloc_hook_c.h' line='99' column='1' id='type-id-385'/>
    <!-- typedef void (void*, typedef ptrdiff_t)* MallocHook_SbrkHook -->
    <typedef-decl name='MallocHook_SbrkHook' type-id='type-id-386' filepath='./src/gperftools/malloc_hook_c.h' line='144' column='1' id='type-id-387'/>
    <!-- class HeapCleaner -->
    <class-decl name='HeapCleaner' size-in-bits='8' visibility='default' filepath='./src/gperftools/heap-checker.h' line='403' column='1' id='type-id-388'>
      <member-type access='private'>
        <!-- typedef void ()* HeapCleaner::void_function -->
        <typedef-decl name='void_function' type-id='type-id-176' filepath='./src/gperftools/heap-checker.h' line='405' column='1' id='type-id-389'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static std::vector<void (*)(), std::allocator<void (*)()> >* HeapCleaner::heap_cleanups_ -->
        <var-decl name='heap_cleanups_' type-id='type-id-390' mangled-name='_ZN11HeapCleaner14heap_cleanups_E' visibility='default' filepath='./src/gperftools/heap-checker.h' line='409' column='1' elf-symbol-id='_ZN11HeapCleaner14heap_cleanups_E'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- HeapCleaner::HeapCleaner(HeapCleaner::void_function) -->
        <function-decl name='HeapCleaner' mangled-name='_ZN11HeapCleanerC1EPFvvE' filepath='./src/gperftools/heap-checker.h' line='406' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11HeapCleanerC1EPFvvE'>
          <!-- implicit parameter of type 'HeapCleaner*' -->
          <parameter type-id='type-id-391' is-artificial='yes'/>
          <!-- parameter of type 'typedef HeapCleaner::void_function' -->
          <parameter type-id='type-id-389'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void HeapCleaner::RunHeapCleanups() -->
        <function-decl name='RunHeapCleanups' mangled-name='_ZN11HeapCleaner15RunHeapCleanupsEv' filepath='./src/gperftools/heap-checker.h' line='407' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11HeapCleaner15RunHeapCleanupsEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- AddressMap<HeapProfileTable::AllocValue>* -->
    <pointer-type-def type-id='type-id-241' size-in-bits='64' id='type-id-288'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster* -->
    <pointer-type-def type-id='type-id-279' size-in-bits='64' id='type-id-291'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::Cluster** -->
    <pointer-type-def type-id='type-id-291' size-in-bits='64' id='type-id-283'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::Entry* -->
    <pointer-type-def type-id='type-id-280' size-in-bits='64' id='type-id-284'/>
    <!-- AddressMap<HeapProfileTable::AllocValue>::Object* -->
    <pointer-type-def type-id='type-id-281' size-in-bits='64' id='type-id-287'/>
    <!-- AllocObject& -->
    <reference-type-def kind='lvalue' type-id='type-id-154' size-in-bits='64' id='type-id-161'/>
    <!-- AllocObject* -->
    <pointer-type-def type-id='type-id-154' size-in-bits='64' id='type-id-156'/>
    <!-- AllocObject* const -->
    <qualified-type-def type-id='type-id-156' const='yes' id='type-id-392'/>
    <!-- AllocObject* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-392' size-in-bits='64' id='type-id-393'/>
    <!-- AllocObject*& -->
    <reference-type-def kind='lvalue' type-id='type-id-156' size-in-bits='64' id='type-id-394'/>
    <!-- DisabledRangeMap* -->
    <pointer-type-def type-id='type-id-372' size-in-bits='64' id='type-id-395'/>
    <!-- DisabledRangeMap** -->
    <pointer-type-def type-id='type-id-395' size-in-bits='64' id='type-id-268'/>
    <!-- GlobalRegionCallerRangeMap* -->
    <pointer-type-def type-id='type-id-374' size-in-bits='64' id='type-id-396'/>
    <!-- GlobalRegionCallerRangeMap** -->
    <pointer-type-def type-id='type-id-396' size-in-bits='64' id='type-id-269'/>
    <!-- GoogleInitializer* -->
    <pointer-type-def type-id='type-id-174' size-in-bits='64' id='type-id-179'/>
    <!-- HeapCleaner* -->
    <pointer-type-def type-id='type-id-388' size-in-bits='64' id='type-id-391'/>
    <!-- HeapLeakChecker* -->
    <pointer-type-def type-id='type-id-259' size-in-bits='64' id='type-id-275'/>
    <!-- HeapLeakChecker::Disabler* -->
    <pointer-type-def type-id='type-id-260' size-in-bits='64' id='type-id-261'/>
    <!-- HeapLeakChecker::RangeValue& -->
    <reference-type-def kind='lvalue' type-id='type-id-266' size-in-bits='64' id='type-id-397'/>
    <!-- HeapProfileBucket* -->
    <pointer-type-def type-id='type-id-212' size-in-bits='64' id='type-id-205'/>
    <!-- HeapProfileTable* -->
    <pointer-type-def type-id='type-id-209' size-in-bits='64' id='type-id-250'/>
    <!-- HeapProfileTable** -->
    <pointer-type-def type-id='type-id-250' size-in-bits='64' id='type-id-270'/>
    <!-- HeapProfileTable::AddNonLiveArgs* -->
    <pointer-type-def type-id='type-id-236' size-in-bits='64' id='type-id-257'/>
    <!-- HeapProfileTable::AllocInfo* -->
    <pointer-type-def type-id='type-id-237' size-in-bits='64' id='type-id-253'/>
    <!-- HeapProfileTable::AllocValue* -->
    <pointer-type-def type-id='type-id-210' size-in-bits='64' id='type-id-215'/>
    <!-- HeapProfileTable::AllocValue::Bucket* -->
    <pointer-type-def type-id='type-id-211' size-in-bits='64' id='type-id-214'/>
    <!-- HeapProfileTable::AllocValue::Bucket** -->
    <pointer-type-def type-id='type-id-214' size-in-bits='64' id='type-id-248'/>
    <!-- HeapProfileTable::AllocationMap* -->
    <pointer-type-def type-id='type-id-227' size-in-bits='64' id='type-id-249'/>
    <!-- HeapProfileTable::BufferArgs* -->
    <pointer-type-def type-id='type-id-246' size-in-bits='64' id='type-id-204'/>
    <!-- HeapProfileTable::DumpArgs* -->
    <pointer-type-def type-id='type-id-216' size-in-bits='64' id='type-id-219'/>
    <!-- HeapProfileTable::DumpArgs::Stats* -->
    <pointer-type-def type-id='type-id-217' size-in-bits='64' id='type-id-218'/>
    <!-- HeapProfileTable::Snapshot* -->
    <pointer-type-def type-id='type-id-220' size-in-bits='64' id='type-id-230'/>
    <!-- HeapProfileTable::Snapshot::ReportState* -->
    <pointer-type-def type-id='type-id-225' size-in-bits='64' id='type-id-234'/>
    <!-- LibraryLiveObjectsStacks* -->
    <pointer-type-def type-id='type-id-376' size-in-bits='64' id='type-id-398'/>
    <!-- LibraryLiveObjectsStacks** -->
    <pointer-type-def type-id='type-id-398' size-in-bits='64' id='type-id-271'/>
    <!-- LiveObjectsStack* -->
    <pointer-type-def type-id='type-id-378' size-in-bits='64' id='type-id-399'/>
    <!-- LiveObjectsStack** -->
    <pointer-type-def type-id='type-id-399' size-in-bits='64' id='type-id-272'/>
    <!-- LowLevelAlloc::Arena* -->
    <pointer-type-def type-id='type-id-79' size-in-bits='64' id='type-id-78'/>
    <!-- MemoryRegionMap::LockHolder* -->
    <pointer-type-def type-id='type-id-194' size-in-bits='64' id='type-id-195'/>
    <!-- MemoryRegionMap::Region* -->
    <pointer-type-def type-id='type-id-184' size-in-bits='64' id='type-id-186'/>
    <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-157' size-in-bits='64' id='type-id-400'/>
    <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-157' size-in-bits='64' id='type-id-158'/>
    <!-- STL_Allocator<char, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-298' size-in-bits='64' id='type-id-299'/>
    <!-- STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-346' size-in-bits='64' id='type-id-347'/>
    <!-- STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-338' size-in-bits='64' id='type-id-401'/>
    <!-- STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-338' size-in-bits='64' id='type-id-339'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-322' size-in-bits='64' id='type-id-402'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-322' size-in-bits='64' id='type-id-323'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-354' size-in-bits='64' id='type-id-403'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-354' size-in-bits='64' id='type-id-355'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-306' size-in-bits='64' id='type-id-404'/>
    <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-306' size-in-bits='64' id='type-id-307'/>
    <!-- STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-330' size-in-bits='64' id='type-id-331'/>
    <!-- STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-362' size-in-bits='64' id='type-id-363'/>
    <!-- STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-314' size-in-bits='64' id='type-id-315'/>
    <!-- STL_Allocator<void*, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-167' size-in-bits='64' id='type-id-405'/>
    <!-- STL_Allocator<void*, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-167' size-in-bits='64' id='type-id-168'/>
    <!-- StackTopSet* -->
    <pointer-type-def type-id='type-id-380' size-in-bits='64' id='type-id-406'/>
    <!-- StackTopSet** -->
    <pointer-type-def type-id='type-id-406' size-in-bits='64' id='type-id-273'/>
    <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-407' size-in-bits='64' id='type-id-408'/>
    <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-407' size-in-bits='64' id='type-id-409'/>
    <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-410' size-in-bits='64' id='type-id-411'/>
    <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-410' size-in-bits='64' id='type-id-412'/>
    <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-413' size-in-bits='64' id='type-id-414'/>
    <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >* -->
    <pointer-type-def type-id='type-id-413' size-in-bits='64' id='type-id-415'/>
    <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-416' size-in-bits='64' id='type-id-417'/>
    <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-416' size-in-bits='64' id='type-id-418'/>
    <!-- __gnu_cxx::new_allocator<void (*)()>* -->
    <pointer-type-def type-id='type-id-419' size-in-bits='64' id='type-id-420'/>
    <!-- base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>* -->
    <pointer-type-def type-id='type-id-421' size-in-bits='64' id='type-id-422'/>
    <!-- base::internal::HookList<void (*)(const void*, ptrdiff_t)>* -->
    <pointer-type-def type-id='type-id-423' size-in-bits='64' id='type-id-424'/>
    <!-- const AddressMap<HeapProfileTable::AllocValue> -->
    <qualified-type-def type-id='type-id-241' const='yes' id='type-id-425'/>
    <!-- const AddressMap<HeapProfileTable::AllocValue>* -->
    <pointer-type-def type-id='type-id-425' size-in-bits='64' id='type-id-289'/>
    <!-- const AllocObject -->
    <qualified-type-def type-id='type-id-154' const='yes' id='type-id-426'/>
    <!-- const AllocObject& -->
    <reference-type-def kind='lvalue' type-id='type-id-426' size-in-bits='64' id='type-id-162'/>
    <!-- const AllocObject* -->
    <pointer-type-def type-id='type-id-426' size-in-bits='64' id='type-id-163'/>
    <!-- const AllocObject* const -->
    <qualified-type-def type-id='type-id-163' const='yes' id='type-id-427'/>
    <!-- const AllocObject* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-427' size-in-bits='64' id='type-id-428'/>
    <!-- const GoogleInitializer::VoidFunction -->
    <qualified-type-def type-id='type-id-175' const='yes' id='type-id-178'/>
    <!-- const HeapLeakChecker -->
    <qualified-type-def type-id='type-id-259' const='yes' id='type-id-429'/>
    <!-- const HeapLeakChecker& -->
    <reference-type-def kind='lvalue' type-id='type-id-429' size-in-bits='64' id='type-id-277'/>
    <!-- const HeapLeakChecker* -->
    <pointer-type-def type-id='type-id-429' size-in-bits='64' id='type-id-276'/>
    <!-- const HeapLeakChecker::Disabler -->
    <qualified-type-def type-id='type-id-260' const='yes' id='type-id-430'/>
    <!-- const HeapLeakChecker::Disabler& -->
    <reference-type-def kind='lvalue' type-id='type-id-430' size-in-bits='64' id='type-id-262'/>
    <!-- const HeapLeakChecker::RangeValue -->
    <qualified-type-def type-id='type-id-266' const='yes' id='type-id-431'/>
    <!-- const HeapLeakChecker::RangeValue& -->
    <reference-type-def kind='lvalue' type-id='type-id-431' size-in-bits='64' id='type-id-432'/>
    <!-- const HeapProfileStats -->
    <qualified-type-def type-id='type-id-164' const='yes' id='type-id-433'/>
    <!-- const HeapProfileStats& -->
    <reference-type-def kind='lvalue' type-id='type-id-433' size-in-bits='64' id='type-id-166'/>
    <!-- const HeapProfileStats* -->
    <pointer-type-def type-id='type-id-433' size-in-bits='64' id='type-id-165'/>
    <!-- const HeapProfileTable -->
    <qualified-type-def type-id='type-id-209' const='yes' id='type-id-434'/>
    <!-- const HeapProfileTable& -->
    <reference-type-def kind='lvalue' type-id='type-id-434' size-in-bits='64' id='type-id-258'/>
    <!-- const HeapProfileTable* -->
    <pointer-type-def type-id='type-id-434' size-in-bits='64' id='type-id-251'/>
    <!-- const HeapProfileTable::AllocContextInfo -->
    <qualified-type-def type-id='type-id-238' const='yes' id='type-id-435'/>
    <!-- const HeapProfileTable::AllocContextInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-435' size-in-bits='64' id='type-id-436'/>
    <!-- const HeapProfileTable::AllocInfo -->
    <qualified-type-def type-id='type-id-237' const='yes' id='type-id-437'/>
    <!-- const HeapProfileTable::AllocInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-437' size-in-bits='64' id='type-id-438'/>
    <!-- const HeapProfileTable::AllocValue -->
    <qualified-type-def type-id='type-id-210' const='yes' id='type-id-439'/>
    <!-- const HeapProfileTable::AllocValue& -->
    <reference-type-def kind='lvalue' type-id='type-id-439' size-in-bits='64' id='type-id-233'/>
    <!-- const HeapProfileTable::AllocValue* -->
    <pointer-type-def type-id='type-id-439' size-in-bits='64' id='type-id-213'/>
    <!-- const HeapProfileTable::AllocValue::Bucket -->
    <qualified-type-def type-id='type-id-211' const='yes' id='type-id-440'/>
    <!-- const HeapProfileTable::AllocValue::Bucket& -->
    <reference-type-def kind='lvalue' type-id='type-id-440' size-in-bits='64' id='type-id-254'/>
    <!-- const HeapProfileTable::AllocValue::Bucket* -->
    <pointer-type-def type-id='type-id-440' size-in-bits='64' id='type-id-255'/>
    <!-- const HeapProfileTable::BufferArgs -->
    <qualified-type-def type-id='type-id-246' const='yes' id='type-id-441'/>
    <!-- const HeapProfileTable::BufferArgs& -->
    <reference-type-def kind='lvalue' type-id='type-id-441' size-in-bits='64' id='type-id-247'/>
    <!-- const HeapProfileTable::DumpArgs -->
    <qualified-type-def type-id='type-id-216' const='yes' id='type-id-442'/>
    <!-- const HeapProfileTable::DumpArgs& -->
    <reference-type-def kind='lvalue' type-id='type-id-442' size-in-bits='64' id='type-id-256'/>
    <!-- const HeapProfileTable::DumpArgs::Stats -->
    <qualified-type-def type-id='type-id-217' const='yes' id='type-id-443'/>
    <!-- const HeapProfileTable::DumpArgs::Stats& -->
    <reference-type-def kind='lvalue' type-id='type-id-443' size-in-bits='64' id='type-id-229'/>
    <!-- const HeapProfileTable::Snapshot -->
    <qualified-type-def type-id='type-id-220' const='yes' id='type-id-444'/>
    <!-- const HeapProfileTable::Snapshot& -->
    <reference-type-def kind='lvalue' type-id='type-id-444' size-in-bits='64' id='type-id-235'/>
    <!-- const HeapProfileTable::Snapshot* -->
    <pointer-type-def type-id='type-id-444' size-in-bits='64' id='type-id-228'/>
    <!-- const MemoryRegionMap::LockHolder -->
    <qualified-type-def type-id='type-id-194' const='yes' id='type-id-445'/>
    <!-- const MemoryRegionMap::LockHolder& -->
    <reference-type-def kind='lvalue' type-id='type-id-445' size-in-bits='64' id='type-id-196'/>
    <!-- const MemoryRegionMap::Region -->
    <qualified-type-def type-id='type-id-184' const='yes' id='type-id-446'/>
    <!-- const MemoryRegionMap::Region& -->
    <reference-type-def kind='lvalue' type-id='type-id-446' size-in-bits='64' id='type-id-183'/>
    <!-- const MemoryRegionMap::Region* -->
    <pointer-type-def type-id='type-id-446' size-in-bits='64' id='type-id-185'/>
    <!-- const STL_Allocator<AllocObject, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-157' const='yes' id='type-id-447'/>
    <!-- const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-447' size-in-bits='64' id='type-id-159'/>
    <!-- const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-447' size-in-bits='64' id='type-id-160'/>
    <!-- const STL_Allocator<char, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-298' const='yes' id='type-id-448'/>
    <!-- const STL_Allocator<char, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-448' size-in-bits='64' id='type-id-300'/>
    <!-- const STL_Allocator<char, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-448' size-in-bits='64' id='type-id-301'/>
    <!-- const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-346' const='yes' id='type-id-449'/>
    <!-- const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-449' size-in-bits='64' id='type-id-348'/>
    <!-- const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-449' size-in-bits='64' id='type-id-349'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-338' const='yes' id='type-id-450'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-450' size-in-bits='64' id='type-id-340'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-450' size-in-bits='64' id='type-id-341'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-322' const='yes' id='type-id-451'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-451' size-in-bits='64' id='type-id-324'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-451' size-in-bits='64' id='type-id-325'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-354' const='yes' id='type-id-452'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-452' size-in-bits='64' id='type-id-356'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-452' size-in-bits='64' id='type-id-357'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-306' const='yes' id='type-id-453'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-453' size-in-bits='64' id='type-id-308'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-453' size-in-bits='64' id='type-id-309'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-330' const='yes' id='type-id-454'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-454' size-in-bits='64' id='type-id-332'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-454' size-in-bits='64' id='type-id-333'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-362' const='yes' id='type-id-455'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-455' size-in-bits='64' id='type-id-364'/>
    <!-- const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-455' size-in-bits='64' id='type-id-365'/>
    <!-- const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-314' const='yes' id='type-id-456'/>
    <!-- const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-456' size-in-bits='64' id='type-id-316'/>
    <!-- const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-456' size-in-bits='64' id='type-id-317'/>
    <!-- const STL_Allocator<void*, HeapLeakChecker::Allocator> -->
    <qualified-type-def type-id='type-id-167' const='yes' id='type-id-457'/>
    <!-- const STL_Allocator<void*, HeapLeakChecker::Allocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-457' size-in-bits='64' id='type-id-169'/>
    <!-- const STL_Allocator<void*, HeapLeakChecker::Allocator>* -->
    <pointer-type-def type-id='type-id-457' size-in-bits='64' id='type-id-170'/>
    <!-- const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
    <qualified-type-def type-id='type-id-407' const='yes' id='type-id-458'/>
    <!-- const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-458' size-in-bits='64' id='type-id-459'/>
    <!-- const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-458' size-in-bits='64' id='type-id-460'/>
    <!-- const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
    <qualified-type-def type-id='type-id-410' const='yes' id='type-id-461'/>
    <!-- const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-461' size-in-bits='64' id='type-id-462'/>
    <!-- const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-461' size-in-bits='64' id='type-id-463'/>
    <!-- const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
    <qualified-type-def type-id='type-id-413' const='yes' id='type-id-464'/>
    <!-- const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-464' size-in-bits='64' id='type-id-465'/>
    <!-- const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >* -->
    <pointer-type-def type-id='type-id-464' size-in-bits='64' id='type-id-466'/>
    <!-- const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
    <qualified-type-def type-id='type-id-416' const='yes' id='type-id-467'/>
    <!-- const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-467' size-in-bits='64' id='type-id-468'/>
    <!-- const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-467' size-in-bits='64' id='type-id-469'/>
    <!-- const __gnu_cxx::new_allocator<void (*)()> -->
    <qualified-type-def type-id='type-id-419' const='yes' id='type-id-470'/>
    <!-- const __gnu_cxx::new_allocator<void (*)()>& -->
    <reference-type-def kind='lvalue' type-id='type-id-470' size-in-bits='64' id='type-id-471'/>
    <!-- const __gnu_cxx::new_allocator<void (*)()>* -->
    <pointer-type-def type-id='type-id-470' size-in-bits='64' id='type-id-472'/>
    <!-- const base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)> -->
    <qualified-type-def type-id='type-id-421' const='yes' id='type-id-473'/>
    <!-- const base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>* -->
    <pointer-type-def type-id='type-id-473' size-in-bits='64' id='type-id-474'/>
    <!-- const base::internal::HookList<void (*)(const void*, ptrdiff_t)> -->
    <qualified-type-def type-id='type-id-423' const='yes' id='type-id-475'/>
    <!-- const base::internal::HookList<void (*)(const void*, ptrdiff_t)>* -->
    <pointer-type-def type-id='type-id-475' size-in-bits='64' id='type-id-476'/>
    <!-- const bool& -->
    <reference-type-def kind='lvalue' type-id='type-id-477' size-in-bits='64' id='type-id-478'/>
    <!-- const char* const -->
    <qualified-type-def type-id='type-id-52' const='yes' id='type-id-177'/>
    <!-- const char* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-177' size-in-bits='64' id='type-id-479'/>
    <!-- const size_t& -->
    <reference-type-def kind='lvalue' type-id='type-id-112' size-in-bits='64' id='type-id-480'/>
    <!-- const std::_Identity<long unsigned int> -->
    <qualified-type-def type-id='type-id-481' const='yes' id='type-id-482'/>
    <!-- const std::_Identity<long unsigned int>* -->
    <pointer-type-def type-id='type-id-482' size-in-bits='64' id='type-id-483'/>
    <!-- const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-484' const='yes' id='type-id-485'/>
    <!-- const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-485' size-in-bits='64' id='type-id-486'/>
    <!-- const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-485' size-in-bits='64' id='type-id-487'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-488' const='yes' id='type-id-489'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-489' size-in-bits='64' id='type-id-490'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-489' size-in-bits='64' id='type-id-491'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-492' const='yes' id='type-id-493'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-493' size-in-bits='64' id='type-id-494'/>
    <!-- const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-493' size-in-bits='64' id='type-id-495'/>
    <!-- const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-496' const='yes' id='type-id-497'/>
    <!-- const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-497' size-in-bits='64' id='type-id-498'/>
    <!-- const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-497' size-in-bits='64' id='type-id-499'/>
    <!-- const std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
    <qualified-type-def type-id='type-id-198' const='yes' id='type-id-500'/>
    <!-- const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-500' size-in-bits='64' id='type-id-501'/>
    <!-- const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-500' size-in-bits='64' id='type-id-502'/>
    <!-- const std::_Rb_tree_const_iterator<long unsigned int> -->
    <qualified-type-def type-id='type-id-503' const='yes' id='type-id-504'/>
    <!-- const std::_Rb_tree_const_iterator<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-504' size-in-bits='64' id='type-id-505'/>
    <!-- const std::_Rb_tree_const_iterator<long unsigned int>* -->
    <pointer-type-def type-id='type-id-504' size-in-bits='64' id='type-id-506'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
    <qualified-type-def type-id='type-id-507' const='yes' id='type-id-508'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-508' size-in-bits='64' id='type-id-509'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-508' size-in-bits='64' id='type-id-510'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
    <qualified-type-def type-id='type-id-511' const='yes' id='type-id-512'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-512' size-in-bits='64' id='type-id-513'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-512' size-in-bits='64' id='type-id-514'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
    <qualified-type-def type-id='type-id-515' const='yes' id='type-id-516'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-516' size-in-bits='64' id='type-id-517'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-516' size-in-bits='64' id='type-id-518'/>
    <!-- const std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
    <qualified-type-def type-id='type-id-519' const='yes' id='type-id-520'/>
    <!-- const std::_Rb_tree_iterator<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-520' size-in-bits='64' id='type-id-521'/>
    <!-- const std::_Rb_tree_iterator<long unsigned int> -->
    <qualified-type-def type-id='type-id-522' const='yes' id='type-id-523'/>
    <!-- const std::_Rb_tree_iterator<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-523' size-in-bits='64' id='type-id-524'/>
    <!-- const std::_Rb_tree_iterator<long unsigned int>* -->
    <pointer-type-def type-id='type-id-523' size-in-bits='64' id='type-id-525'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
    <qualified-type-def type-id='type-id-526' const='yes' id='type-id-527'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-527' size-in-bits='64' id='type-id-528'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-527' size-in-bits='64' id='type-id-529'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
    <qualified-type-def type-id='type-id-530' const='yes' id='type-id-531'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-531' size-in-bits='64' id='type-id-532'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-531' size-in-bits='64' id='type-id-533'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
    <qualified-type-def type-id='type-id-534' const='yes' id='type-id-535'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-535' size-in-bits='64' id='type-id-536'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-535' size-in-bits='64' id='type-id-537'/>
    <!-- const std::_Rb_tree_node<MemoryRegionMap::Region> -->
    <qualified-type-def type-id='type-id-538' const='yes' id='type-id-539'/>
    <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-539' size-in-bits='64' id='type-id-540'/>
    <!-- const std::_Rb_tree_node<long unsigned int> -->
    <qualified-type-def type-id='type-id-541' const='yes' id='type-id-542'/>
    <!-- const std::_Rb_tree_node<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-542' size-in-bits='64' id='type-id-344'/>
    <!-- const std::_Rb_tree_node<long unsigned int>* -->
    <pointer-type-def type-id='type-id-542' size-in-bits='64' id='type-id-345'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
    <qualified-type-def type-id='type-id-543' const='yes' id='type-id-544'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-544' size-in-bits='64' id='type-id-328'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-544' size-in-bits='64' id='type-id-329'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> > -->
    <qualified-type-def type-id='type-id-545' const='yes' id='type-id-546'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-546' size-in-bits='64' id='type-id-360'/>
    <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-546' size-in-bits='64' id='type-id-361'/>
    <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
    <qualified-type-def type-id='type-id-547' const='yes' id='type-id-548'/>
    <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-548' size-in-bits='64' id='type-id-312'/>
    <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-548' size-in-bits='64' id='type-id-313'/>
    <!-- const std::_Rb_tree_node_base -->
    <qualified-type-def type-id='type-id-549' const='yes' id='type-id-550'/>
    <!-- const std::_Rb_tree_node_base* -->
    <pointer-type-def type-id='type-id-550' size-in-bits='64' id='type-id-551'/>
    <!-- const std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
    <qualified-type-def type-id='type-id-552' const='yes' id='type-id-553'/>
    <!-- const std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-553' size-in-bits='64' id='type-id-554'/>
    <!-- const std::_Select1st<std::pair<const long unsigned int, long unsigned int> > -->
    <qualified-type-def type-id='type-id-555' const='yes' id='type-id-556'/>
    <!-- const std::_Select1st<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-556' size-in-bits='64' id='type-id-557'/>
    <!-- const std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
    <qualified-type-def type-id='type-id-558' const='yes' id='type-id-559'/>
    <!-- const std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-559' size-in-bits='64' id='type-id-560'/>
    <!-- const std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-561' const='yes' id='type-id-562'/>
    <!-- const std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-562' size-in-bits='64' id='type-id-563'/>
    <!-- const std::_Vector_base<void (*)(), std::allocator<void (*)()> > -->
    <qualified-type-def type-id='type-id-564' const='yes' id='type-id-565'/>
    <!-- const std::_Vector_base<void (*)(), std::allocator<void (*)()> >* -->
    <pointer-type-def type-id='type-id-565' size-in-bits='64' id='type-id-566'/>
    <!-- const std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-567' const='yes' id='type-id-568'/>
    <!-- const std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-568' size-in-bits='64' id='type-id-569'/>
    <!-- const std::allocator<void (*)()> -->
    <qualified-type-def type-id='type-id-570' const='yes' id='type-id-571'/>
    <!-- const std::allocator<void (*)()>& -->
    <reference-type-def kind='lvalue' type-id='type-id-571' size-in-bits='64' id='type-id-572'/>
    <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-573' const='yes' id='type-id-574'/>
    <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-574' size-in-bits='64' id='type-id-575'/>
    <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-574' size-in-bits='64' id='type-id-576'/>
    <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep -->
    <qualified-type-def type-id='type-id-577' const='yes' id='type-id-578'/>
    <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* -->
    <pointer-type-def type-id='type-id-578' size-in-bits='64' id='type-id-579'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep -->
    <qualified-type-def type-id='type-id-580' const='yes' id='type-id-581'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
    <pointer-type-def type-id='type-id-581' size-in-bits='64' id='type-id-582'/>
    <!-- const std::char_traits<char>::char_type -->
    <qualified-type-def type-id='type-id-583' const='yes' id='type-id-584'/>
    <!-- const std::char_traits<char>::char_type& -->
    <reference-type-def kind='lvalue' type-id='type-id-584' size-in-bits='64' id='type-id-585'/>
    <!-- const std::char_traits<char>::char_type* -->
    <pointer-type-def type-id='type-id-584' size-in-bits='64' id='type-id-586'/>
    <!-- const std::char_traits<char>::int_type -->
    <qualified-type-def type-id='type-id-587' const='yes' id='type-id-588'/>
    <!-- const std::char_traits<char>::int_type& -->
    <reference-type-def kind='lvalue' type-id='type-id-588' size-in-bits='64' id='type-id-589'/>
    <!-- const std::less<long unsigned int> -->
    <qualified-type-def type-id='type-id-590' const='yes' id='type-id-591'/>
    <!-- const std::less<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-591' size-in-bits='64' id='type-id-592'/>
    <!-- const std::less<long unsigned int>* -->
    <pointer-type-def type-id='type-id-591' size-in-bits='64' id='type-id-593'/>
    <!-- const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
    <qualified-type-def type-id='type-id-594' const='yes' id='type-id-595'/>
    <!-- const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-595' size-in-bits='64' id='type-id-596'/>
    <!-- const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-595' size-in-bits='64' id='type-id-597'/>
    <!-- const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-371' const='yes' id='type-id-598'/>
    <!-- const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-598' size-in-bits='64' id='type-id-599'/>
    <!-- const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-598' size-in-bits='64' id='type-id-600'/>
    <!-- const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-373' const='yes' id='type-id-601'/>
    <!-- const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-601' size-in-bits='64' id='type-id-602'/>
    <!-- const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-601' size-in-bits='64' id='type-id-603'/>
    <!-- const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-375' const='yes' id='type-id-604'/>
    <!-- const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-604' size-in-bits='64' id='type-id-605'/>
    <!-- const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-604' size-in-bits='64' id='type-id-606'/>
    <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue> -->
    <qualified-type-def type-id='type-id-607' const='yes' id='type-id-608'/>
    <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
    <reference-type-def kind='lvalue' type-id='type-id-608' size-in-bits='64' id='type-id-336'/>
    <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
    <pointer-type-def type-id='type-id-608' size-in-bits='64' id='type-id-337'/>
    <!-- const std::pair<const long unsigned int, long unsigned int> -->
    <qualified-type-def type-id='type-id-609' const='yes' id='type-id-610'/>
    <!-- const std::pair<const long unsigned int, long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-610' size-in-bits='64' id='type-id-368'/>
    <!-- const std::pair<const long unsigned int, long unsigned int>* -->
    <pointer-type-def type-id='type-id-610' size-in-bits='64' id='type-id-369'/>
    <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
    <qualified-type-def type-id='type-id-611' const='yes' id='type-id-612'/>
    <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-612' size-in-bits='64' id='type-id-320'/>
    <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-612' size-in-bits='64' id='type-id-321'/>
    <!-- const std::pair<long unsigned int, HeapLeakChecker::RangeValue> -->
    <qualified-type-def type-id='type-id-613' const='yes' id='type-id-614'/>
    <!-- const std::pair<long unsigned int, HeapLeakChecker::RangeValue>& -->
    <reference-type-def kind='lvalue' type-id='type-id-614' size-in-bits='64' id='type-id-615'/>
    <!-- const std::pair<long unsigned int, long unsigned int> -->
    <qualified-type-def type-id='type-id-616' const='yes' id='type-id-617'/>
    <!-- const std::pair<long unsigned int, long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-617' size-in-bits='64' id='type-id-618'/>
    <!-- const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-379' const='yes' id='type-id-619'/>
    <!-- const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-619' size-in-bits='64' id='type-id-620'/>
    <!-- const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-619' size-in-bits='64' id='type-id-621'/>
    <!-- const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-377' const='yes' id='type-id-622'/>
    <!-- const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-622' size-in-bits='64' id='type-id-623'/>
    <!-- const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-622' size-in-bits='64' id='type-id-624'/>
    <!-- const std::vector<void (*)(), std::allocator<void (*)()> > -->
    <qualified-type-def type-id='type-id-625' const='yes' id='type-id-626'/>
    <!-- const std::vector<void (*)(), std::allocator<void (*)()> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-626' size-in-bits='64' id='type-id-627'/>
    <!-- const std::vector<void (*)(), std::allocator<void (*)()> >* -->
    <pointer-type-def type-id='type-id-626' size-in-bits='64' id='type-id-628'/>
    <!-- const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > -->
    <qualified-type-def type-id='type-id-629' const='yes' id='type-id-630'/>
    <!-- const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-630' size-in-bits='64' id='type-id-631'/>
    <!-- const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-630' size-in-bits='64' id='type-id-632'/>
    <!-- const uint32_t -->
    <qualified-type-def type-id='type-id-12' const='yes' id='type-id-285'/>
    <!-- const unsigned long int* -->
    <pointer-type-def type-id='type-id-633' size-in-bits='64' id='type-id-353'/>
    <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-484' size-in-bits='64' id='type-id-634'/>
    <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-484' size-in-bits='64' id='type-id-635'/>
    <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>* -->
    <pointer-type-def type-id='type-id-636' size-in-bits='64' id='type-id-637'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-488' size-in-bits='64' id='type-id-638'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-488' size-in-bits='64' id='type-id-639'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>* -->
    <pointer-type-def type-id='type-id-640' size-in-bits='64' id='type-id-641'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-492' size-in-bits='64' id='type-id-642'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-492' size-in-bits='64' id='type-id-643'/>
    <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>* -->
    <pointer-type-def type-id='type-id-644' size-in-bits='64' id='type-id-645'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-496' size-in-bits='64' id='type-id-646'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-496' size-in-bits='64' id='type-id-647'/>
    <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>* -->
    <pointer-type-def type-id='type-id-648' size-in-bits='64' id='type-id-649'/>
    <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-198' size-in-bits='64' id='type-id-650'/>
    <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-198' size-in-bits='64' id='type-id-651'/>
    <!-- std::_Rb_tree_const_iterator<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-503' size-in-bits='64' id='type-id-652'/>
    <!-- std::_Rb_tree_const_iterator<long unsigned int>* -->
    <pointer-type-def type-id='type-id-503' size-in-bits='64' id='type-id-653'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-507' size-in-bits='64' id='type-id-654'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-507' size-in-bits='64' id='type-id-655'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-511' size-in-bits='64' id='type-id-656'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-511' size-in-bits='64' id='type-id-657'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-515' size-in-bits='64' id='type-id-658'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-515' size-in-bits='64' id='type-id-659'/>
    <!-- std::_Rb_tree_iterator<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-522' size-in-bits='64' id='type-id-660'/>
    <!-- std::_Rb_tree_iterator<long unsigned int>* -->
    <pointer-type-def type-id='type-id-522' size-in-bits='64' id='type-id-661'/>
    <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-526' size-in-bits='64' id='type-id-662'/>
    <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-526' size-in-bits='64' id='type-id-663'/>
    <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-530' size-in-bits='64' id='type-id-664'/>
    <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-530' size-in-bits='64' id='type-id-665'/>
    <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-534' size-in-bits='64' id='type-id-666'/>
    <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-534' size-in-bits='64' id='type-id-667'/>
    <!-- std::_Rb_tree_node<long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-541' size-in-bits='64' id='type-id-342'/>
    <!-- std::_Rb_tree_node<long unsigned int>* -->
    <pointer-type-def type-id='type-id-541' size-in-bits='64' id='type-id-343'/>
    <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-543' size-in-bits='64' id='type-id-326'/>
    <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
    <pointer-type-def type-id='type-id-543' size-in-bits='64' id='type-id-327'/>
    <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-545' size-in-bits='64' id='type-id-358'/>
    <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
    <pointer-type-def type-id='type-id-545' size-in-bits='64' id='type-id-359'/>
    <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-547' size-in-bits='64' id='type-id-310'/>
    <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
    <pointer-type-def type-id='type-id-547' size-in-bits='64' id='type-id-311'/>
    <!-- std::_Rb_tree_node_base* -->
    <pointer-type-def type-id='type-id-549' size-in-bits='64' id='type-id-668'/>
    <!-- std::_Rb_tree_node_base*& -->
    <reference-type-def kind='lvalue' type-id='type-id-668' size-in-bits='64' id='type-id-669'/>
    <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-561' size-in-bits='64' id='type-id-670'/>
    <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl* -->
    <pointer-type-def type-id='type-id-671' size-in-bits='64' id='type-id-672'/>
    <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >* -->
    <pointer-type-def type-id='type-id-564' size-in-bits='64' id='type-id-673'/>
    <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl* -->
    <pointer-type-def type-id='type-id-674' size-in-bits='64' id='type-id-675'/>
    <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-567' size-in-bits='64' id='type-id-676'/>
    <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl* -->
    <pointer-type-def type-id='type-id-677' size-in-bits='64' id='type-id-678'/>
    <!-- std::allocator<void (*)()>& -->
    <reference-type-def kind='lvalue' type-id='type-id-570' size-in-bits='64' id='type-id-679'/>
    <!-- std::allocator<void (*)()>* -->
    <pointer-type-def type-id='type-id-570' size-in-bits='64' id='type-id-680'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-573' size-in-bits='64' id='type-id-681'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-573' size-in-bits='64' id='type-id-682'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider* -->
    <pointer-type-def type-id='type-id-683' size-in-bits='64' id='type-id-684'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep& -->
    <reference-type-def kind='lvalue' type-id='type-id-577' size-in-bits='64' id='type-id-685'/>
    <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* -->
    <pointer-type-def type-id='type-id-577' size-in-bits='64' id='type-id-686'/>
    <!-- std::char_traits<char>::char_type& -->
    <reference-type-def kind='lvalue' type-id='type-id-583' size-in-bits='64' id='type-id-687'/>
    <!-- std::char_traits<char>::char_type* -->
    <pointer-type-def type-id='type-id-583' size-in-bits='64' id='type-id-688'/>
    <!-- std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-371' size-in-bits='64' id='type-id-689'/>
    <!-- std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-371' size-in-bits='64' id='type-id-690'/>
    <!-- std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-373' size-in-bits='64' id='type-id-691'/>
    <!-- std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-373' size-in-bits='64' id='type-id-692'/>
    <!-- std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-375' size-in-bits='64' id='type-id-693'/>
    <!-- std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-375' size-in-bits='64' id='type-id-694'/>
    <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
    <reference-type-def kind='lvalue' type-id='type-id-607' size-in-bits='64' id='type-id-334'/>
    <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
    <pointer-type-def type-id='type-id-607' size-in-bits='64' id='type-id-335'/>
    <!-- std::pair<const long unsigned int, long unsigned int>& -->
    <reference-type-def kind='lvalue' type-id='type-id-609' size-in-bits='64' id='type-id-366'/>
    <!-- std::pair<const long unsigned int, long unsigned int>* -->
    <pointer-type-def type-id='type-id-609' size-in-bits='64' id='type-id-367'/>
    <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-611' size-in-bits='64' id='type-id-318'/>
    <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
    <pointer-type-def type-id='type-id-611' size-in-bits='64' id='type-id-319'/>
    <!-- std::pair<long unsigned int, HeapLeakChecker::RangeValue>* -->
    <pointer-type-def type-id='type-id-613' size-in-bits='64' id='type-id-695'/>
    <!-- std::pair<long unsigned int, long unsigned int>* -->
    <pointer-type-def type-id='type-id-616' size-in-bits='64' id='type-id-696'/>
    <!-- std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>* -->
    <pointer-type-def type-id='type-id-697' size-in-bits='64' id='type-id-698'/>
    <!-- std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>* -->
    <pointer-type-def type-id='type-id-699' size-in-bits='64' id='type-id-700'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>* -->
    <pointer-type-def type-id='type-id-701' size-in-bits='64' id='type-id-702'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>* -->
    <pointer-type-def type-id='type-id-703' size-in-bits='64' id='type-id-704'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>* -->
    <pointer-type-def type-id='type-id-705' size-in-bits='64' id='type-id-706'/>
    <!-- std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-379' size-in-bits='64' id='type-id-707'/>
    <!-- std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-379' size-in-bits='64' id='type-id-708'/>
    <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-377' size-in-bits='64' id='type-id-709'/>
    <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-377' size-in-bits='64' id='type-id-710'/>
    <!-- std::vector<void (*)(), std::allocator<void (*)()> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-625' size-in-bits='64' id='type-id-711'/>
    <!-- std::vector<void (*)(), std::allocator<void (*)()> >* -->
    <pointer-type-def type-id='type-id-625' size-in-bits='64' id='type-id-390'/>
    <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-629' size-in-bits='64' id='type-id-712'/>
    <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >* -->
    <pointer-type-def type-id='type-id-629' size-in-bits='64' id='type-id-713'/>
    <!-- typedef size_t (const HeapProfileTable::AllocValue&)* -->
    <pointer-type-def type-id='type-id-714' size-in-bits='64' id='type-id-290'/>
    <!-- unsigned long int& -->
    <reference-type-def kind='lvalue' type-id='type-id-5' size-in-bits='64' id='type-id-350'/>
    <!-- unsigned long int* -->
    <pointer-type-def type-id='type-id-5' size-in-bits='64' id='type-id-351'/>
    <!-- void ()* const -->
    <qualified-type-def type-id='type-id-176' const='yes' id='type-id-715'/>
    <!-- void ()* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-715' size-in-bits='64' id='type-id-716'/>
    <!-- void ()* const* -->
    <pointer-type-def type-id='type-id-715' size-in-bits='64' id='type-id-717'/>
    <!-- void ()*& -->
    <reference-type-def kind='lvalue' type-id='type-id-176' size-in-bits='64' id='type-id-718'/>
    <!-- void ()** -->
    <pointer-type-def type-id='type-id-176' size-in-bits='64' id='type-id-719'/>
    <!-- void ()** const -->
    <qualified-type-def type-id='type-id-719' const='yes' id='type-id-720'/>
    <!-- void ()** const& -->
    <reference-type-def kind='lvalue' type-id='type-id-720' size-in-bits='64' id='type-id-721'/>
    <!-- void (const HeapProfileTable::AllocContextInfo&)* -->
    <pointer-type-def type-id='type-id-722' size-in-bits='64' id='type-id-245'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, void (void*, const HeapProfileTable::AllocInfo&)*)* -->
    <pointer-type-def type-id='type-id-723' size-in-bits='64' id='type-id-292'/>
    <!-- void (void*, const HeapProfileTable::AllocInfo&)* -->
    <pointer-type-def type-id='type-id-724' size-in-bits='64' id='type-id-243'/>
    <!-- void (void*, typedef ptrdiff_t)* -->
    <pointer-type-def type-id='type-id-725' size-in-bits='64' id='type-id-386'/>
    <!-- void (void*, typedef ptrdiff_t)** -->
    <pointer-type-def type-id='type-id-386' size-in-bits='64' id='type-id-726'/>
    <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)* -->
    <pointer-type-def type-id='type-id-727' size-in-bits='64' id='type-id-384'/>
    <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)** -->
    <pointer-type-def type-id='type-id-384' size-in-bits='64' id='type-id-728'/>
    <!-- void* (typedef size_t)* -->
    <pointer-type-def type-id='type-id-729' size-in-bits='64' id='type-id-239'/>
    <!-- void* const -->
    <qualified-type-def type-id='type-id-53' const='yes' id='type-id-54'/>
    <!-- void* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-54' size-in-bits='64' id='type-id-172'/>
    <!-- void* const* -->
    <pointer-type-def type-id='type-id-54' size-in-bits='64' id='type-id-173'/>
    <!-- void*& -->
    <reference-type-def kind='lvalue' type-id='type-id-53' size-in-bits='64' id='type-id-171'/>
    <!-- void** const -->
    <qualified-type-def type-id='type-id-141' const='yes' id='type-id-730'/>
    <!-- void** const& -->
    <reference-type-def kind='lvalue' type-id='type-id-730' size-in-bits='64' id='type-id-731'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- struct std::random_access_iterator_tag -->
      <class-decl name='random_access_iterator_tag' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_types.h' line='89' column='1' id='type-id-732'>
        <!-- struct std::bidirectional_iterator_tag -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-733'/>
      </class-decl>
      <!-- struct std::bidirectional_iterator_tag -->
      <class-decl name='bidirectional_iterator_tag' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_types.h' line='86' column='1' id='type-id-733'>
        <!-- struct std::forward_iterator_tag -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-734'/>
      </class-decl>
      <!-- struct std::forward_iterator_tag -->
      <class-decl name='forward_iterator_tag' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_types.h' line='83' column='1' id='type-id-734'>
        <!-- struct std::input_iterator_tag -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-735'/>
      </class-decl>
      <!-- struct std::input_iterator_tag -->
      <class-decl name='input_iterator_tag' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_types.h' line='79' column='1' id='type-id-735'/>
      <!-- struct std::pair<long unsigned int, HeapLeakChecker::RangeValue> -->
      <class-decl name='pair&lt;long unsigned int, HeapLeakChecker::RangeValue&gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-613'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- unsigned long int std::pair<long unsigned int, HeapLeakChecker::RangeValue>::first -->
          <var-decl name='first' type-id='type-id-5' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- HeapLeakChecker::RangeValue std::pair<long unsigned int, HeapLeakChecker::RangeValue>::second -->
          <var-decl name='second' type-id='type-id-266' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<long unsigned int, HeapLeakChecker::RangeValue>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<long unsigned int, HeapLeakChecker::RangeValue>*' -->
            <parameter type-id='type-id-695' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<long unsigned int, HeapLeakChecker::RangeValue>::pair(const unsigned long int&, const HeapLeakChecker::RangeValue&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<long unsigned int, HeapLeakChecker::RangeValue>*' -->
            <parameter type-id='type-id-695' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- parameter of type 'const HeapLeakChecker::RangeValue&' -->
            <parameter type-id='type-id-432'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_node_base -->
      <class-decl name='_Rb_tree_node_base' size-in-bits='256' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='88' column='1' id='type-id-549'>
        <member-type access='public'>
          <!-- typedef std::_Rb_tree_node_base* std::_Rb_tree_node_base::_Base_ptr -->
          <typedef-decl name='_Base_ptr' type-id='type-id-668' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='89' column='1' id='type-id-736'/>
        </member-type>
        <member-type access='public'>
          <!-- typedef const std::_Rb_tree_node_base* std::_Rb_tree_node_base::_Const_Base_ptr -->
          <typedef-decl name='_Const_Base_ptr' type-id='type-id-551' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='90' column='1' id='type-id-737'/>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_color std::_Rb_tree_node_base::_M_color -->
          <var-decl name='_M_color' type-id='type-id-738' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='92' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_node_base::_M_parent -->
          <var-decl name='_M_parent' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='93' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_node_base::_M_left -->
          <var-decl name='_M_left' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='94' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='192'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_node_base::_M_right -->
          <var-decl name='_M_right' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='95' column='1'/>
        </data-member>
        <member-function access='public' static='yes'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_node_base::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt18_Rb_tree_node_base10_S_minimumEPS_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef std::_Rb_tree_node_base::_Base_ptr' -->
            <parameter type-id='type-id-736'/>
            <!-- typedef std::_Rb_tree_node_base::_Base_ptr -->
            <return type-id='type-id-736'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_node_base::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt18_Rb_tree_node_base10_S_minimumEPKS_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='105' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef std::_Rb_tree_node_base::_Const_Base_ptr' -->
            <parameter type-id='type-id-737'/>
            <!-- typedef std::_Rb_tree_node_base::_Const_Base_ptr -->
            <return type-id='type-id-737'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_node_base::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt18_Rb_tree_node_base10_S_maximumEPS_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='112' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef std::_Rb_tree_node_base::_Base_ptr' -->
            <parameter type-id='type-id-736'/>
            <!-- typedef std::_Rb_tree_node_base::_Base_ptr -->
            <return type-id='type-id-736'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_node_base::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt18_Rb_tree_node_base10_S_maximumEPKS_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef std::_Rb_tree_node_base::_Const_Base_ptr' -->
            <parameter type-id='type-id-737'/>
            <!-- typedef std::_Rb_tree_node_base::_Const_Base_ptr -->
            <return type-id='type-id-737'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<void (*)()> -->
      <class-decl name='allocator&lt;void (*)()&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-570'>
        <!-- class __gnu_cxx::new_allocator<void (*)()> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-419'/>
        <member-function access='private'>
          <!-- void std::allocator<void (*)()>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<void (*)()>*' -->
            <parameter type-id='type-id-680' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<void (*)()>::allocator(const std::allocator<void (*)()>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<void (*)()>*' -->
            <parameter type-id='type-id-680' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<void (*)()>&' -->
            <parameter type-id='type-id-572'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<void (*)()>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<void (*)()>*' -->
            <parameter type-id='type-id-680' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<long unsigned int, long unsigned int> -->
      <class-decl name='pair&lt;long unsigned int, long unsigned int&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-616'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- unsigned long int std::pair<long unsigned int, long unsigned int>::first -->
          <var-decl name='first' type-id='type-id-5' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- unsigned long int std::pair<long unsigned int, long unsigned int>::second -->
          <var-decl name='second' type-id='type-id-5' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<long unsigned int, long unsigned int>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<long unsigned int, long unsigned int>*' -->
            <parameter type-id='type-id-696' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<long unsigned int, long unsigned int>::pair(const unsigned long int&, const unsigned long int&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<long unsigned int, long unsigned int>*' -->
            <parameter type-id='type-id-696' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<void**, false> -->
      <class-decl name='__niter_base&lt;void**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-739'>
        <member-function access='public' static='yes'>
          <!-- void** std::__niter_base<void**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPPvLb0EE3__bES1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<void**, false> -->
      <class-decl name='__miter_base&lt;void**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-740'>
        <member-function access='public' static='yes'>
          <!-- void** std::__miter_base<void**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPPvLb0EE3__bES1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
      <class-decl name='_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-198'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::_Rb_tree_const_iterator(const std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<MemoryRegionMap::Region>&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-521'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-502' is-artificial='yes'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const MemoryRegionMap::Region* std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-502' is-artificial='yes'/>
            <!-- const MemoryRegionMap::Region* -->
            <return type-id='type-id-185'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& -->
            <return type-id='type-id-650'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region>& -->
            <return type-id='type-id-650'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-651' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator==(const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEeqERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-502' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-501'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<MemoryRegionMap::Region>::operator!=(const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorIN15MemoryRegionMap6RegionEEneERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-502' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-501'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
      <class-decl name='_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-519'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<MemoryRegionMap::Region>::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<MemoryRegionMap::Region>::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<MemoryRegionMap::Region>::_Rb_tree_iterator(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- MemoryRegionMap::Region& std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-743' is-artificial='yes'/>
            <!-- MemoryRegionMap::Region& -->
            <return type-id='type-id-744'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- MemoryRegionMap::Region* std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-743' is-artificial='yes'/>
            <!-- MemoryRegionMap::Region* -->
            <return type-id='type-id-186'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& -->
            <return type-id='type-id-745'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& -->
            <return type-id='type-id-745'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-741' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator==(const std::_Rb_tree_iterator<MemoryRegionMap::Region>&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEeqERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-743' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-521'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<MemoryRegionMap::Region>::operator!=(const std::_Rb_tree_iterator<MemoryRegionMap::Region>&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorIN15MemoryRegionMap6RegionEEneERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-743' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-521'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__copy_move_backward<false, false, std::random_access_iterator_tag> -->
      <class-decl name='__copy_move_backward&lt;false, false, std::random_access_iterator_tag&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='539' column='1' id='type-id-746'>
        <member-function access='public' static='yes'>
          <!-- AllocObject* std::__copy_move_backward<false, false, std::random_access_iterator_tag>::__copy_move_b<AllocObject*, AllocObject*>(AllocObject*, AllocObject*) -->
          <function-decl name='__copy_move_b&lt;AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='542' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::Snapshot::Entry* std::__copy_move_backward<false, false, std::random_access_iterator_tag>::__copy_move_b<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
          <function-decl name='__copy_move_b&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='542' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- HeapProfileTable::Snapshot::Entry* -->
            <return type-id='type-id-222'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Vector_base&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='70' column='1' id='type-id-561'>
        <member-type access='public'>
          <!-- struct std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl -->
          <class-decl name='_Vector_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='75' column='1' id='type-id-671'>
            <!-- class STL_Allocator<AllocObject, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-157'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- AllocObject* std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl::_M_start -->
              <var-decl name='_M_start' type-id='type-id-156' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='76' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- AllocObject* std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl::_M_finish -->
              <var-decl name='_M_finish' type-id='type-id-156' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='77' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- AllocObject* std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl::_M_end_of_storage -->
              <var-decl name='_M_end_of_storage' type-id='type-id-156' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='78' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl::_Vector_impl() -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl*' -->
                <parameter type-id='type-id-672' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl::_Vector_impl(const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl*' -->
                <parameter type-id='type-id-672' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-159'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_impl std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-671' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='136' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNSt12_Vector_baseI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-400'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt12_Vector_baseI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-563' is-artificial='yes'/>
            <!-- const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-159'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- STL_Allocator<AllocObject, HeapLeakChecker::Allocator> std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt12_Vector_baseI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-563' is-artificial='yes'/>
            <!-- class STL_Allocator<AllocObject, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-157'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_base() -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_base(const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-159'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_Vector_base(unsigned long int, const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-159'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::~_Vector_base(int) -->
          <function-decl name='~_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- AllocObject* std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_allocate(unsigned long int) -->
          <function-decl name='_M_allocate' mangled-name='_ZNSt12_Vector_baseI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE11_M_allocateEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_deallocate(AllocObject*, unsigned long int) -->
          <function-decl name='_M_deallocate' mangled-name='_ZNSt12_Vector_baseI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_deallocateEPS0_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-670' is-artificial='yes'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__alloc_swap<STL_Allocator<AllocObject, HeapLeakChecker::Allocator>, true> -->
      <class-decl name='__alloc_swap&lt;STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt;, true&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='148' column='1' id='type-id-747'>
        <member-function access='public' static='yes'>
          <!-- void std::__alloc_swap<STL_Allocator<AllocObject, HeapLeakChecker::Allocator>, true>::_S_do_it(STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_S_do_it' mangled-name='_ZNSt12__alloc_swapI13STL_AllocatorI11AllocObjectN15HeapLeakChecker9AllocatorEELb1EE8_S_do_itERS4_S6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-400'/>
            <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-400'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > -->
      <class-decl name='basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='105' column='1' id='type-id-573'>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider -->
          <class-decl name='_Alloc_hider' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='258' column='1' id='type-id-683'>
            <!-- class STL_Allocator<char, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-298'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider::_M_p -->
              <var-decl name='_M_p' type-id='type-id-113' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='262' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider::_Alloc_hider(char*, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Alloc_hider' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider*' -->
                <parameter type-id='type-id-684' is-artificial='yes'/>
                <!-- parameter of type 'char*' -->
                <parameter type-id='type-id-113'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep -->
          <class-decl name='_Rep' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='148' column='1' id='type-id-577'>
            <!-- struct std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep_base -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-748'/>
            <data-member access='public' static='yes'>
              <!-- static const size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_max_size -->
              <var-decl name='_S_max_size' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='51' column='1'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static const char std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_terminal -->
              <var-decl name='_S_terminal' type-id='type-id-58' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep11_S_terminalE' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='56' column='1' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep11_S_terminalE'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_empty_rep_storage[4] -->
              <var-decl name='_S_empty_rep_storage' type-id='type-id-150' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep20_S_empty_rep_storageE' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='68' column='1' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep20_S_empty_rep_storageE'/>
            </data-member>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_empty_rep() -->
              <function-decl name='_S_empty_rep' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep& -->
                <return type-id='type-id-685'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_is_leaked() -->
              <function-decl name='_M_is_leaked' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep12_M_is_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-579' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_is_shared() -->
              <function-decl name='_M_is_shared' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep12_M_is_sharedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='187' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-579' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_set_leaked() -->
              <function-decl name='_M_set_leaked' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep13_M_set_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='191' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_set_sharable() -->
              <function-decl name='_M_set_sharable' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep15_M_set_sharableEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_set_length_and_sharable(unsigned long int) -->
              <function-decl name='_M_set_length_and_sharable' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep26_M_set_length_and_sharableEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_refdata() -->
              <function-decl name='_M_refdata' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_refdataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_grab(const STL_Allocator<char, HeapLeakChecker::Allocator>&, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_M_grab' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep7_M_grabERKS4_S8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='218' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_S_create(unsigned long int, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_S_create' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep9_S_createEmmRKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='546' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep9_S_createEmmRKS4_'>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* -->
                <return type-id='type-id-686'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_dispose(const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_M_dispose' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_disposeERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_destroy(const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_M_destroy' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_destroyERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='445' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_destroyERKS4_'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_refcopy() -->
              <function-decl name='_M_refcopy' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep10_M_refcopyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep::_M_clone(const STL_Allocator<char, HeapLeakChecker::Allocator>&, unsigned long int) -->
              <function-decl name='_M_clone' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4_Rep8_M_cloneERKS4_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='624' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep*' -->
                <parameter type-id='type-id-686' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-300'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep_base -->
          <class-decl name='_Rep_base' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='141' column='1' id='type-id-748'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep_base::_M_length -->
              <var-decl name='_M_length' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='142' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep_base::_M_capacity -->
              <var-decl name='_M_capacity' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='143' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- _Atomic_word std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep_base::_M_refcount -->
              <var-decl name='_M_refcount' type-id='type-id-370' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='144' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <data-member access='private' static='yes'>
          <!-- static const size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::npos -->
          <var-decl name='npos' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='270' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Alloc_hider std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_dataplus -->
          <var-decl name='_M_dataplus' type-id='type-id-683' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='274' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_data() -->
          <function-decl name='_M_data' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_data(char*) -->
          <function-decl name='_M_data' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_dataEPc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_rep() -->
          <function-decl name='_M_rep' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6_M_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='285' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep* -->
            <return type-id='type-id-686'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_ibegin() -->
          <function-decl name='_M_ibegin' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE9_M_ibeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_iend() -->
          <function-decl name='_M_iend' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_iendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_leak() -->
          <function-decl name='_M_leak' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_leakEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_check(unsigned long int, const char*) -->
          <function-decl name='_M_check' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE8_M_checkEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_check_length(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='_M_check_length' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE15_M_check_lengthEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='314' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_limit(unsigned long int, unsigned long int) -->
          <function-decl name='_M_limit' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE8_M_limitEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='322' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_disjunct(const char*) -->
          <function-decl name='_M_disjunct' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE11_M_disjunctEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_copy(const char*, unsigned long int) -->
          <function-decl name='_M_copy' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_copyEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='339' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_move(const char*, unsigned long int) -->
          <function-decl name='_M_move' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7_M_moveEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='348' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_assign(unsigned long int, char) -->
          <function-decl name='_M_assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE9_M_assignEPcmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='357' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_copy_chars(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIS6_S5_EES9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_copy_chars(__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIPKcS5_EESB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='380' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-750'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-750'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_copy_chars(char*, char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13_S_copy_charsEPcS6_S6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_copy_chars(const char*, const char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13_S_copy_charsEPcPKcS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='388' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_compare(unsigned long int) -->
          <function-decl name='_S_compare' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE10_S_compareEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='392' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_mutate(unsigned long int, unsigned long int, unsigned long int) -->
          <function-decl name='_M_mutate' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE9_M_mutateEmmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_leak_hard() -->
          <function-decl name='_M_leak_hard' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12_M_leak_hardEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_empty_rep() -->
          <function-decl name='_S_empty_rep' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='411' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_Rep& -->
            <return type-id='type-id-685'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string() -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2144' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='basic_string' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC1ERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='170' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC1ERKS5_'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='194' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const char*, unsigned long int, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(const char*, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='basic_string' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC2EPKcRKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='213' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEC2EPKcRKS4_'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::basic_string(unsigned long int, char, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='220' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::~basic_string(int) -->
          <function-decl name='~basic_string' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEED1Ev' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='502' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEED1Ev'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator=(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEaSERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='510' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator=(const char*) -->
          <function-decl name='operator=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEaSEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator=(char) -->
          <function-decl name='operator=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEaSEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='554' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-750'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='573' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-750'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-751'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='602' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-752'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='611' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-751'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='620' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-752'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::length() -->
          <function-decl name='length' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6lengthEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::resize(unsigned long int, char) -->
          <function-decl name='resize' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6resizeEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='640' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::resize(unsigned long int) -->
          <function-decl name='resize' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6resizeEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='502' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='708' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='740' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='761' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='780' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator+=(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator+=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEpLERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='795' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator+=(const char*) -->
          <function-decl name='operator+=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEpLEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='804' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::operator+=(char) -->
          <function-decl name='operator+=' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEpLEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='813' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::append(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='append' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6appendERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='325' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::append(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6appendERKS5_mm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::append(const char*, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6appendEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='298' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::append(const char*) -->
          <function-decl name='append' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6appendEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='868' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::append(unsigned long int, char) -->
          <function-decl name='append' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6appendEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::push_back(char) -->
          <function-decl name='push_back' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE9push_backEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='914' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::assign(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6assignERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::assign(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6assignERKS5_mm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='944' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::assign(const char*, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6assignEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::assign(const char*) -->
          <function-decl name='assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6assignEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='972' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::assign(unsigned long int, char) -->
          <function-decl name='assign' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6assignEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='988' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPcS5_EEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1028' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEmRKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1071' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEmRKS5_mm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1093' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(unsigned long int, const char*, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(unsigned long int, const char*) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(unsigned long int, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1157' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, char) -->
          <function-decl name='insert' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPcS5_EEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::erase(unsigned long int, unsigned long int) -->
          <function-decl name='erase' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5eraseEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1198' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPcS5_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1214' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='391' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-749'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEmmRKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEmmRKS5_mm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1275' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_RKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1359' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_PKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1377' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_PKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1398' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_mc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1419' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, char*, char*) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_S8_S8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, const char*, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_PKcSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_S9_S9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1476' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='replace' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7replaceEN9__gnu_cxx17__normal_iteratorIPcS5_EES9_NS7_IPKcS5_EESC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1486' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-749'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-750'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-750'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_replace_aux(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='_M_replace_aux' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE14_M_replace_auxEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_M_replace_safe(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='_M_replace_safe' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE15_M_replace_safeEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='681' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-681'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_construct(char, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_S_construct' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12_S_constructEmcRKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::copy(char*, unsigned long int, unsigned long int) -->
          <function-decl name='copy' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4copyEPcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::swap(std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4swapERS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='519' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-682' is-artificial='yes'/>
            <!-- parameter of type 'std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-681'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::c_str() -->
          <function-decl name='c_str' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5c_strEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1612' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1622' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<char, HeapLeakChecker::Allocator> std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1629' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- class STL_Allocator<char, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-298'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4findEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='737' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4findERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1657' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find(const char*, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4findEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1671' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find(char, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE4findEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='760' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rfind(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5rfindERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rfind(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5rfindEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='778' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rfind(const char*, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5rfindEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1729' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::rfind(char, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE5rfindEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_of(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13find_first_ofERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1759' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13find_first_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='816' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_of(const char*, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13find_first_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1787' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_of(char, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE13find_first_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1806' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_of(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12find_last_ofERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1820' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12find_last_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='831' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_of(const char*, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12find_last_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1848' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_of(char, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE12find_last_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1867' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_not_of(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE17find_first_not_ofERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1881' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE17find_first_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_not_of(const char*, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE17find_first_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1910' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_first_not_of(char, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE17find_first_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='864' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_not_of(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE16find_last_not_ofERKS5_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1940' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE16find_last_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='875' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_not_of(const char*, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE16find_last_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1969' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::find_last_not_of(char, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE16find_last_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='896' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::substr(unsigned long int, unsigned long int) -->
          <function-decl name='substr' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE6substrEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2001' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- class std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > -->
            <return type-id='type-id-573'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2019' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareEmmRKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='916' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, unsigned long int, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareEmmRKS5_mm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='931' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='949' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='964' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::compare(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEE7compareEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='980' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_construct<const char*>(const char*, const STL_Allocator<char, HeapLeakChecker::Allocator>&, std::forward_iterator_tag) -->
          <function-decl name='_S_construct&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- parameter of type 'struct std::forward_iterator_tag' -->
            <parameter type-id='type-id-734'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_construct_aux<const char*>(const char*, const STL_Allocator<char, HeapLeakChecker::Allocator>&, std::__false_type) -->
          <function-decl name='_S_construct_aux&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- parameter of type 'struct std::__false_type' -->
            <parameter type-id='type-id-753'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >::_S_construct<const char*>(const char*, const STL_Allocator<char, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_S_construct&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1556' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const STL_Allocator<char, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-300'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::char_traits<char> -->
      <class-decl name='char_traits&lt;char&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='238' column='1' id='type-id-754'>
        <member-type access='public'>
          <!-- typedef char std::char_traits<char>::char_type -->
          <typedef-decl name='char_type' type-id='type-id-60' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='239' column='1' id='type-id-583'/>
        </member-type>
        <member-type access='public'>
          <!-- typedef int std::char_traits<char>::int_type -->
          <typedef-decl name='int_type' type-id='type-id-1' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='240' column='1' id='type-id-587'/>
        </member-type>
        <member-function access='public' static='yes'>
          <!-- void std::char_traits<char>::assign(const std::char_traits<char>::char_type&) -->
          <function-decl name='assign' mangled-name='_ZNSt11char_traitsIcE6assignERcRKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='246' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-687'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- bool std::char_traits<char>::eq(const std::char_traits<char>::char_type&) -->
          <function-decl name='eq' mangled-name='_ZNSt11char_traitsIcE2eqERKcS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='250' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- bool std::char_traits<char>::lt(const std::char_traits<char>::char_type&) -->
          <function-decl name='lt' mangled-name='_ZNSt11char_traitsIcE2ltERKcS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='254' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- int std::char_traits<char>::compare(const std::char_traits<char>::char_type*, size_t) -->
          <function-decl name='compare' mangled-name='_ZNSt11char_traitsIcE7compareEPKcS2_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- size_t std::char_traits<char>::length() -->
          <function-decl name='length' mangled-name='_ZNSt11char_traitsIcE6lengthEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='262' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- const std::char_traits<char>::char_type* std::char_traits<char>::find(size_t, const std::char_traits<char>::char_type&) -->
          <function-decl name='find' mangled-name='_ZNSt11char_traitsIcE4findEPKcmRS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='266' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- const std::char_traits<char>::char_type* -->
            <return type-id='type-id-586'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::char_type* std::char_traits<char>::move(const std::char_traits<char>::char_type*, size_t) -->
          <function-decl name='move' mangled-name='_ZNSt11char_traitsIcE4moveEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='270' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-688'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- std::char_traits<char>::char_type* -->
            <return type-id='type-id-688'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::char_type* std::char_traits<char>::copy(const std::char_traits<char>::char_type*, size_t) -->
          <function-decl name='copy' mangled-name='_ZNSt11char_traitsIcE4copyEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='274' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-688'/>
            <!-- parameter of type 'const std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-586'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- std::char_traits<char>::char_type* -->
            <return type-id='type-id-688'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::char_type* std::char_traits<char>::assign(size_t, std::char_traits<char>::char_type) -->
          <function-decl name='assign' mangled-name='_ZNSt11char_traitsIcE6assignEPcmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::char_traits<char>::char_type*' -->
            <parameter type-id='type-id-688'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- parameter of type 'typedef std::char_traits<char>::char_type' -->
            <parameter type-id='type-id-583'/>
            <!-- std::char_traits<char>::char_type* -->
            <return type-id='type-id-688'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::char_type std::char_traits<char>::to_char_type() -->
          <function-decl name='to_char_type' mangled-name='_ZNSt11char_traitsIcE12to_char_typeERKi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='282' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::int_type&' -->
            <parameter type-id='type-id-589'/>
            <!-- typedef std::char_traits<char>::char_type -->
            <return type-id='type-id-583'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::int_type std::char_traits<char>::to_int_type() -->
          <function-decl name='to_int_type' mangled-name='_ZNSt11char_traitsIcE11to_int_typeERKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='288' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::char_type&' -->
            <parameter type-id='type-id-585'/>
            <!-- typedef std::char_traits<char>::int_type -->
            <return type-id='type-id-587'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- bool std::char_traits<char>::eq_int_type(const std::char_traits<char>::int_type&) -->
          <function-decl name='eq_int_type' mangled-name='_ZNSt11char_traitsIcE11eq_int_typeERKiS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='292' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::int_type&' -->
            <parameter type-id='type-id-589'/>
            <!-- parameter of type 'const std::char_traits<char>::int_type&' -->
            <parameter type-id='type-id-589'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::int_type std::char_traits<char>::eof() -->
          <function-decl name='eof' mangled-name='_ZNSt11char_traitsIcE3eofEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- typedef std::char_traits<char>::int_type -->
            <return type-id='type-id-587'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- std::char_traits<char>::int_type std::char_traits<char>::not_eof() -->
          <function-decl name='not_eof' mangled-name='_ZNSt11char_traitsIcE7not_eofERKi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/char_traits.h' line='300' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::char_traits<char>::int_type&' -->
            <parameter type-id='type-id-589'/>
            <!-- typedef std::char_traits<char>::int_type -->
            <return type-id='type-id-587'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__false_type -->
      <class-decl name='__false_type' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/cpp_type_traits.h' line='79' column='1' id='type-id-753'/>
      <!-- class std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > -->
      <class-decl name='vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='192' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='171' column='1' id='type-id-377'>
        <!-- struct std::_Vector_base<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-561'/>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::vector() -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::vector(const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-159'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::vector(unsigned long int, const AllocObject&, const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- parameter of type 'const STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-159'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::vector(const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-623'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::~vector(int) -->
          <function-decl name='~vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::operator=(const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEaSERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-623'/>
            <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-709'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::assign(unsigned long int, const AllocObject&) -->
          <function-decl name='assign' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6assignEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='434' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-755'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-756'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='479' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-755'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-756'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='537' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::resize(unsigned long int, AllocObject) -->
          <function-decl name='resize' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6resizeEmS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='552' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'struct AllocObject' -->
            <parameter type-id='type-id-154'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='574' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_range_check(unsigned long int) -->
          <function-decl name='_M_range_check' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_range_checkEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='679' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='703' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject* std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::data() -->
          <function-decl name='data' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='714' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject* std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- const AllocObject* -->
            <return type-id='type-id-163'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::push_back(const AllocObject&) -->
          <function-decl name='push_back' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE9push_backERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='733' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, const AllocObject&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, unsigned long int, const AllocObject&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPS0_S5_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPS0_S5_EES9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::swap(std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4swapERS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-709'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='950' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_fill_initialize(unsigned long int, const AllocObject&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE18_M_fill_initializeEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1033' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_fill_assign(unsigned long int, const AllocObject&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_fill_assignEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_fill_insert(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, unsigned long int, const AllocObject&) -->
          <function-decl name='_M_fill_insert' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_insert_aux(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, const AllocObject&) -->
          <function-decl name='_M_insert_aux' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- parameter of type 'const AllocObject&' -->
            <parameter type-id='type-id-162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- size_t std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_check_len(unsigned long int, const char*) -->
          <function-decl name='_M_check_len' mangled-name='_ZNKSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE12_M_check_lenEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-624' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >::_M_erase_at_end(AllocObject*) -->
          <function-decl name='_M_erase_at_end' mangled-name='_ZNSt6vectorI11AllocObject13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE15_M_erase_at_endEPS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-710' is-artificial='yes'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
      <class-decl name='_Rb_tree_iterator&lt;long unsigned int&gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-522'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<long unsigned int>::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<long unsigned int>::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<long unsigned int>::_Rb_tree_iterator(std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- unsigned long int& std::_Rb_tree_iterator<long unsigned int>::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorImEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-525' is-artificial='yes'/>
            <!-- unsigned long int& -->
            <return type-id='type-id-350'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- unsigned long int* std::_Rb_tree_iterator<long unsigned int>::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorImEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-525' is-artificial='yes'/>
            <!-- unsigned long int* -->
            <return type-id='type-id-351'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<long unsigned int>& std::_Rb_tree_iterator<long unsigned int>::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorImEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<long unsigned int>& -->
            <return type-id='type-id-660'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree_iterator<long unsigned int>::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorImEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<long unsigned int>& std::_Rb_tree_iterator<long unsigned int>::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorImEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<long unsigned int>& -->
            <return type-id='type-id-660'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree_iterator<long unsigned int>::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorImEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-661' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<long unsigned int>::operator==(const std::_Rb_tree_iterator<long unsigned int>&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorImEeqERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-525' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-524'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<long unsigned int>::operator!=(const std::_Rb_tree_iterator<long unsigned int>&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorImEneERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-525' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-524'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- enum std::_Rb_tree_color -->
      <enum-decl name='_Rb_tree_color' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='85' column='1' id='type-id-738'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='_S_red' value='0'/>
        <enumerator name='_S_black' value='1'/>
      </enum-decl>
      <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-534'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-537' is-artificial='yes'/>
            <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-318'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-537' is-artificial='yes'/>
            <!-- std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
            <return type-id='type-id-319'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
            <return type-id='type-id-666'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
            <return type-id='type-id-666'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-667' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator==(const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEeqERKSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-537' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-536'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator!=(const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEneERKSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-537' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-536'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
      <class-decl name='less&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='227' column='1' id='type-id-594'>
        <!-- struct std::binary_function<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, bool> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-757'/>
        <member-function access='public'>
          <!-- bool std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >::operator()(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt4lessISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEEEclERKS6_S9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-597' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::binary_function<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, bool> -->
      <class-decl name='binary_function&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, bool&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='113' column='1' id='type-id-757'/>
      <!-- class std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Rb_tree&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, std::_Select1st&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;, std::less&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;, STL_Allocator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-496'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-648'>
            <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-306'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-594' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>*' -->
                <parameter type-id='type-id-649' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_Rb_tree_impl(const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&, const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>*' -->
                <parameter type-id='type-id-649' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&' -->
                <parameter type-id='type-id-596'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-308'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE13_Rb_tree_implISH_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false>*' -->
                <parameter type-id='type-id-649' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, false> std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-648' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-404'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-308'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-314'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_put_node(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11_M_put_nodeEPSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_create_node(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE14_M_create_nodeERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_destroy_node(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_clone_node(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE13_M_clone_nodeEPKSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-313'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-313'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_S_valueEPKSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-320'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6_S_keyEPKSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-575'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-313'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-313'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-320'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-575'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_M_insert_EPKSt18_Rb_tree_node_baseSM_RKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE10_M_insert_EPKSt18_Rb_tree_node_baseSM_RKSD_'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE15_M_insert_lowerEPSt18_Rb_tree_node_baseSL_RKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_equal_lower(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE21_M_insert_equal_lowerERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_copy(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE7_M_copyEPKSt13_Rb_tree_nodeISD_EPSL_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >* -->
            <return type-id='type-id-311'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_M_eraseEPSt13_Rb_tree_nodeISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8_M_eraseEPSt13_Rb_tree_nodeISD_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_lower_bound(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE14_M_lower_boundEPSt13_Rb_tree_nodeISD_ESM_RS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_lower_bound(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE14_M_lower_boundEPKSt13_Rb_tree_nodeISD_ESN_RS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_upper_bound(std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE14_M_upper_boundEPSt13_Rb_tree_nodeISD_ESM_RS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-311'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_upper_bound(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE14_M_upper_boundEPKSt13_Rb_tree_nodeISD_ESN_RS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree(const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&, const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-596'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-316'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_Rb_tree(const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-498'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::operator=(const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EEaSERKSJ_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-498'/>
            <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-646'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- struct std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-594'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-758'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-759'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-758'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-759'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::swap(std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4swapERSJ_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-646'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool> std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_unique(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE16_M_insert_uniqueERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE16_M_insert_uniqueERKSD_'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool> -->
            <return type-id='type-id-705'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_equal(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE15_M_insert_equalERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorISD_ERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorISD_ERKSD_'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-515'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE16_M_insert_equal_ESt23_Rb_tree_const_iteratorISD_ERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-515'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseESt17_Rb_tree_iteratorISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseESt23_Rb_tree_const_iteratorISD_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-515'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseESt17_Rb_tree_iteratorISD_ESL_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseESt23_Rb_tree_const_iteratorISD_ESL_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-515'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-515'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5eraseEPS8_SK_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-576'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::find(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::find(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::count(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE5countERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::lower_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::lower_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::upper_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::upper_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::equal_range(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-647' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-760'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::equal_range(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-761'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt4pairIKS6_St6vectorI11AllocObjectS2_ISA_S4_EEESt10_Select1stISD_ESt4lessIS6_ES2_ISD_S4_EE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-499' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-526'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-529' is-artificial='yes'/>
            <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
            <return type-id='type-id-334'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-529' is-artificial='yes'/>
            <!-- std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
            <return type-id='type-id-335'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
            <return type-id='type-id-662'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
            <return type-id='type-id-662'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-663' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator==(const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEeqERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-529' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-528'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator!=(const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEneERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-529' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-528'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::less<long unsigned int> -->
      <class-decl name='less&lt;long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='227' column='1' id='type-id-590'>
        <!-- struct std::binary_function<long unsigned int, long unsigned int, bool> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-762'/>
        <member-function access='public'>
          <!-- bool std::less<long unsigned int>::operator()(const unsigned long int&, const unsigned long int&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt4lessImEclERKmS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::less<long unsigned int>*' -->
            <parameter type-id='type-id-593' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::binary_function<long unsigned int, long unsigned int, bool> -->
      <class-decl name='binary_function&lt;long unsigned int, long unsigned int, bool&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='113' column='1' id='type-id-762'/>
      <!-- class std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Rb_tree&lt;long unsigned int, std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;, std::_Select1st&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-488'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;long unsigned int&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-640'>
            <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-322'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-590' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-641' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl(const std::less<long unsigned int>&, const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-641' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<long unsigned int>&' -->
                <parameter type-id='type-id-592'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-324'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE13_Rb_tree_implIS8_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-641' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-640' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-402'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-324'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-330'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_put_node(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11_M_put_nodeEPSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_create_node(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE14_M_create_nodeERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_destroy_node(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_clone_node(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-329'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-329'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_S_valueEPKSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
            <return type-id='type-id-336'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6_S_keyEPKSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-329'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-329'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
            <return type-id='type-id-336'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS4_'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE15_M_insert_lowerEPSt18_Rb_tree_node_baseSE_RKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_equal_lower(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE21_M_insert_equal_lowerERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_copy(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE7_M_copyEPKSt13_Rb_tree_nodeIS4_EPSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >* -->
            <return type-id='type-id-327'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS4_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_lower_bound(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE14_M_lower_boundEPSt13_Rb_tree_nodeIS4_ESF_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_lower_bound(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE14_M_lower_boundEPKSt13_Rb_tree_nodeIS4_ESG_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_upper_bound(std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE14_M_upper_boundEPSt13_Rb_tree_nodeIS4_ESF_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-327'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_upper_bound(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE14_M_upper_boundEPKSt13_Rb_tree_nodeIS4_ESG_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree(const std::less<long unsigned int>&, const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-332'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_Rb_tree(const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-490'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::operator=(const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEEaSERKSC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-490'/>
            <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-638'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-763'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-764'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-763'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-764'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::swap(std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4swapERSC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-638'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_unique(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE16_M_insert_uniqueERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool> -->
            <return type-id='type-id-701'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_equal(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE15_M_insert_equalERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS4_ERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-507'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS4_ERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-507'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS4_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-507'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS4_ESE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS4_ESE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-507'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-507'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(const unsigned long int*, const unsigned long int*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5eraseEPS1_SD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4findERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE4findERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE5countERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11lower_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11lower_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11upper_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11upper_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11equal_rangeERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-639' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-765'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11equal_rangeERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-766'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmN15HeapLeakChecker10RangeValueEESt10_Select1stIS4_ESt4lessImE13STL_AllocatorIS4_NS2_9AllocatorEEE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-491' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
      <class-decl name='_Rb_tree_const_iterator&lt;long unsigned int&gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-503'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<long unsigned int>::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<long unsigned int>::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<long unsigned int>::_Rb_tree_const_iterator(const std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<long unsigned int>::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<long unsigned int>&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-524'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Rb_tree_const_iterator<long unsigned int>::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorImEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-506' is-artificial='yes'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const unsigned long int* std::_Rb_tree_const_iterator<long unsigned int>::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorImEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-506' is-artificial='yes'/>
            <!-- const unsigned long int* -->
            <return type-id='type-id-353'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int>& std::_Rb_tree_const_iterator<long unsigned int>::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorImEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<long unsigned int>& -->
            <return type-id='type-id-652'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree_const_iterator<long unsigned int>::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorImEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int>& std::_Rb_tree_const_iterator<long unsigned int>::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorImEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<long unsigned int>& -->
            <return type-id='type-id-652'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree_const_iterator<long unsigned int>::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorImEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-653' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<long unsigned int>::operator==(const std::_Rb_tree_const_iterator<long unsigned int>&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorImEeqERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-506' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-505'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<long unsigned int>::operator!=(const std::_Rb_tree_const_iterator<long unsigned int>&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorImEneERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>*' -->
            <parameter type-id='type-id-506' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-505'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Rb_tree&lt;long unsigned int, long unsigned int, std::_Identity&lt;long unsigned int&gt;, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;long unsigned int, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-484'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;long unsigned int&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-636'>
            <!-- class STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-338'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-590' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-637' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl(const std::less<long unsigned int>&, const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-637' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<long unsigned int>&' -->
                <parameter type-id='type-id-592'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-340'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE13_Rb_tree_implIS3_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-637' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-636' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-401'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<long unsigned int>, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-340'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- class STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-346'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_put_node(std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11_M_put_nodeEPSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_create_node(const unsigned long int&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE14_M_create_nodeERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_destroy_node(std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE15_M_destroy_nodeEPSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_clone_node(const std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE13_M_clone_nodeEPKSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-345'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-345'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_S_valueEPKSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6_S_keyEPKSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-345'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-345'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const unsigned long int&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKm'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const unsigned long int&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE15_M_insert_lowerEPSt18_Rb_tree_node_baseSA_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_equal_lower(const unsigned long int&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE21_M_insert_equal_lowerERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<long unsigned int>* std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_copy(const std::_Rb_tree_node<long unsigned int>*, std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE7_M_copyEPKSt13_Rb_tree_nodeImEPSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- std::_Rb_tree_node<long unsigned int>* -->
            <return type-id='type-id-343'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<long unsigned int>*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeImE'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_lower_bound(std::_Rb_tree_node<long unsigned int>*, std::_Rb_tree_node<long unsigned int>*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE14_M_lower_boundEPSt13_Rb_tree_nodeImESB_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_lower_bound(const std::_Rb_tree_node<long unsigned int>*, const std::_Rb_tree_node<long unsigned int>*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE14_M_lower_boundEPKSt13_Rb_tree_nodeImESC_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_upper_bound(std::_Rb_tree_node<long unsigned int>*, std::_Rb_tree_node<long unsigned int>*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE14_M_upper_boundEPSt13_Rb_tree_nodeImESB_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- parameter of type 'std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-343'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_upper_bound(const std::_Rb_tree_node<long unsigned int>*, const std::_Rb_tree_node<long unsigned int>*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE14_M_upper_boundEPKSt13_Rb_tree_nodeImESC_RKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- parameter of type 'const std::_Rb_tree_node<long unsigned int>*' -->
            <parameter type-id='type-id-345'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree(const std::less<long unsigned int>&, const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-348'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_Rb_tree(const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-486'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::operator=(const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEEaSERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-486'/>
            <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-634'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<long unsigned int> > -->
            <return type-id='type-id-767'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-768'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<long unsigned int> > -->
            <return type-id='type-id-767'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-768'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::swap(std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4swapERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-634'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<long unsigned int>, bool> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_unique(const unsigned long int&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE16_M_insert_uniqueERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<long unsigned int>, bool> -->
            <return type-id='type-id-699'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_equal(const unsigned long int&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE15_M_insert_equalERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<long unsigned int>, const unsigned long int&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE17_M_insert_unique_ESt23_Rb_tree_const_iteratorImERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<long unsigned int>, const unsigned long int&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE16_M_insert_equal_ESt23_Rb_tree_const_iteratorImERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<long unsigned int>' -->
            <parameter type-id='type-id-522'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<long unsigned int>, std::_Rb_tree_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorImESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<long unsigned int>' -->
            <parameter type-id='type-id-522'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<long unsigned int>' -->
            <parameter type-id='type-id-522'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorImESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(const unsigned long int*, const unsigned long int*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseEPKmSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4findERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4findERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5countERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11lower_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11lower_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11upper_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<long unsigned int> -->
            <return type-id='type-id-522'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11upper_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<long unsigned int>, std::_Rb_tree_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11equal_rangeERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-635' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<long unsigned int>, std::_Rb_tree_iterator<long unsigned int> > -->
            <return type-id='type-id-769'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11equal_rangeERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-770'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeImmSt9_IdentityImESt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-487' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-530'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const long unsigned int, long unsigned int>& std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmmEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-533' is-artificial='yes'/>
            <!-- std::pair<const long unsigned int, long unsigned int>& -->
            <return type-id='type-id-366'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const long unsigned int, long unsigned int>* std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmmEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-533' is-artificial='yes'/>
            <!-- std::pair<const long unsigned int, long unsigned int>* -->
            <return type-id='type-id-367'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmmEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
            <return type-id='type-id-664'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmmEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmmEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
            <return type-id='type-id-664'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKmmEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-665' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator==(const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmmEEeqERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-533' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-532'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >::operator!=(const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKmmEEneERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-533' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-532'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Rb_tree&lt;long unsigned int, std::pair&lt;const long unsigned int, long unsigned int&gt;, std::_Select1st&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-492'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;long unsigned int&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-644'>
            <!-- class STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-354'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-590' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-645' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_Rb_tree_impl(const std::less<long unsigned int>&, const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-645' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<long unsigned int>&' -->
                <parameter type-id='type-id-592'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-356'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE13_Rb_tree_implIS6_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false>*' -->
                <parameter type-id='type-id-645' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree_impl<std::less<long unsigned int>, false> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-644' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-403'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-356'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-362'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_put_node(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_create_node(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE14_M_create_nodeERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_destroy_node(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_clone_node(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-361'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-361'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const long unsigned int, long unsigned int>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_S_valueEPKSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- const std::pair<const long unsigned int, long unsigned int>& -->
            <return type-id='type-id-368'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6_S_keyEPKSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-361'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-361'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const long unsigned int, long unsigned int>& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<const long unsigned int, long unsigned int>& -->
            <return type-id='type-id-368'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const unsigned long int& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSE_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSE_RKS2_'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE15_M_insert_lowerEPSt18_Rb_tree_node_baseSD_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_equal_lower(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE21_M_insert_equal_lowerERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_copy(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE7_M_copyEPKSt13_Rb_tree_nodeIS2_EPSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >* -->
            <return type-id='type-id-359'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_erase(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS2_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_lower_bound(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE14_M_lower_boundEPSt13_Rb_tree_nodeIS2_ESE_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_lower_bound(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const unsigned long int&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE14_M_lower_boundEPKSt13_Rb_tree_nodeIS2_ESF_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_upper_bound(std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE14_M_upper_boundEPSt13_Rb_tree_nodeIS2_ESE_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-359'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_upper_bound(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*, const unsigned long int&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE14_M_upper_boundEPKSt13_Rb_tree_nodeIS2_ESF_RS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree(const std::less<long unsigned int>&, const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-364'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_Rb_tree(const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-494'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::operator=(const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEEaSERKSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-494'/>
            <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-642'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-771'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-772'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-771'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-772'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::swap(std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4swapERSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-642'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool> std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_unique(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE16_M_insert_uniqueERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool> -->
            <return type-id='type-id-703'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_equal(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE15_M_insert_equalERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS2_ERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-511'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS2_ERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-511'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS2_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-511'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS2_ESD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS2_ESD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-511'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-511'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(const unsigned long int*, const unsigned long int*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5eraseEPS1_SC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- parameter of type 'const unsigned long int*' -->
            <parameter type-id='type-id-353'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4findERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE4findERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE5countERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11lower_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11lower_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11upper_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11upper_boundERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11equal_rangeERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-643' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-773'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11equal_rangeERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-774'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeImSt4pairIKmmESt10_Select1stIS2_ESt4lessImE13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-495' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Identity<long unsigned int> -->
      <class-decl name='_Identity&lt;long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='469' column='1' id='type-id-481'>
        <!-- struct std::unary_function<long unsigned int, long unsigned int> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-775'/>
        <member-function access='public'>
          <!-- unsigned long int& std::_Identity<long unsigned int>::operator()(unsigned long int&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt9_IdentityImEclERm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Identity<long unsigned int>*' -->
            <parameter type-id='type-id-483' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int&' -->
            <parameter type-id='type-id-350'/>
            <!-- unsigned long int& -->
            <return type-id='type-id-350'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Identity<long unsigned int>::operator()(const unsigned long int&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt9_IdentityImEclERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='475' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Identity<long unsigned int>*' -->
            <parameter type-id='type-id-483' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<long unsigned int, long unsigned int> -->
      <class-decl name='unary_function&lt;long unsigned int, long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-775'/>
      <!-- struct std::_Select1st<std::pair<const long unsigned int, long unsigned int> > -->
      <class-decl name='_Select1st&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='482' column='1' id='type-id-555'>
        <!-- struct std::unary_function<std::pair<const long unsigned int, long unsigned int>, const long unsigned int> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-776'/>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Select1st<std::pair<const long unsigned int, long unsigned int> >::operator()(std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKmmEEclERS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-557' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-366'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Select1st<std::pair<const long unsigned int, long unsigned int> >::operator()(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKmmEEclERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-557' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<std::pair<const long unsigned int, long unsigned int>, const long unsigned int> -->
      <class-decl name='unary_function&lt;std::pair&lt;const long unsigned int, long unsigned int&gt;, const long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-776'/>
      <!-- struct std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > -->
      <class-decl name='_Vector_base&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='70' column='1' id='type-id-567'>
        <member-type access='public'>
          <!-- struct std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl -->
          <class-decl name='_Vector_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='75' column='1' id='type-id-677'>
            <!-- class STL_Allocator<void*, HeapLeakChecker::Allocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-167'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- void** std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl::_M_start -->
              <var-decl name='_M_start' type-id='type-id-141' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='76' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- void** std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl::_M_finish -->
              <var-decl name='_M_finish' type-id='type-id-141' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='77' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- void** std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl::_M_end_of_storage -->
              <var-decl name='_M_end_of_storage' type-id='type-id-141' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='78' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl::_Vector_impl() -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl*' -->
                <parameter type-id='type-id-678' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl::_Vector_impl(const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl*' -->
                <parameter type-id='type-id-678' is-artificial='yes'/>
                <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
                <parameter type-id='type-id-169'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_impl std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-677' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='136' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- STL_Allocator<void*, HeapLeakChecker::Allocator>& std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNSt12_Vector_baseIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- STL_Allocator<void*, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-405'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const STL_Allocator<void*, HeapLeakChecker::Allocator>& std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt12_Vector_baseIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-569' is-artificial='yes'/>
            <!-- const STL_Allocator<void*, HeapLeakChecker::Allocator>& -->
            <return type-id='type-id-169'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- STL_Allocator<void*, HeapLeakChecker::Allocator> std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt12_Vector_baseIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-569' is-artificial='yes'/>
            <!-- class STL_Allocator<void*, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-167'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_base() -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_base(const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-169'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_Vector_base(unsigned long int, const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-169'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::~_Vector_base(int) -->
          <function-decl name='~_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void** std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_allocate(unsigned long int) -->
          <function-decl name='_M_allocate' mangled-name='_ZNSt12_Vector_baseIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE11_M_allocateEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_deallocate(void**, unsigned long int) -->
          <function-decl name='_M_deallocate' mangled-name='_ZNSt12_Vector_baseIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_deallocateEPS0_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-676' is-artificial='yes'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<const long unsigned int, long unsigned int> -->
      <class-decl name='pair&lt;const long unsigned int, long unsigned int&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-609'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- const unsigned long int std::pair<const long unsigned int, long unsigned int>::first -->
          <var-decl name='first' type-id='type-id-633' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- unsigned long int std::pair<const long unsigned int, long unsigned int>::second -->
          <var-decl name='second' type-id='type-id-5' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, long unsigned int>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
            <parameter type-id='type-id-367' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, long unsigned int>::pair(const unsigned long int&, const unsigned long int&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
            <parameter type-id='type-id-367' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, long unsigned int>::pair<long unsigned int, long unsigned int>(const std::pair<long unsigned int, long unsigned int>&) -->
          <function-decl name='pair&lt;long unsigned int, long unsigned int&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, long unsigned int>*' -->
            <parameter type-id='type-id-367' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-618'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
      <class-decl name='_Select1st&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='482' column='1' id='type-id-552'>
        <!-- struct std::unary_function<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, const long unsigned int> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-777'/>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator()(std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKmN15HeapLeakChecker10RangeValueEEEclERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-554' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-334'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const unsigned long int& std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator()(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKmN15HeapLeakChecker10RangeValueEEEclERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-554' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, const long unsigned int> -->
      <class-decl name='unary_function&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;, const long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-777'/>
      <!-- struct std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='_Select1st&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='482' column='1' id='type-id-558'>
        <!-- struct std::unary_function<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-778'/>
        <member-function access='public'>
          <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator()(std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEclERSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-560' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-318'/>
            <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-575'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator()(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEclERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-560' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-575'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
      <class-decl name='unary_function&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-778'/>
      <!-- struct std::_Vector_base<void (*)(), std::allocator<void (*)()> > -->
      <class-decl name='_Vector_base&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='70' column='1' id='type-id-564'>
        <member-type access='public'>
          <!-- struct std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl -->
          <class-decl name='_Vector_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='75' column='1' id='type-id-674'>
            <!-- class std::allocator<void (*)()> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-570'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- void ()** std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl::_M_start -->
              <var-decl name='_M_start' type-id='type-id-719' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='76' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- void ()** std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl::_M_finish -->
              <var-decl name='_M_finish' type-id='type-id-719' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='77' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- void ()** std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl::_M_end_of_storage -->
              <var-decl name='_M_end_of_storage' type-id='type-id-719' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='78' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl::_Vector_impl() -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl*' -->
                <parameter type-id='type-id-675' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl::_Vector_impl(const std::allocator<void (*)()>&) -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl*' -->
                <parameter type-id='type-id-675' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<void (*)()>&' -->
                <parameter type-id='type-id-572'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_impl std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-674' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='136' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- std::allocator<void (*)()>& std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNSt12_Vector_baseIPFvvESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- std::allocator<void (*)()>& -->
            <return type-id='type-id-679'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::allocator<void (*)()>& std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt12_Vector_baseIPFvvESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-566' is-artificial='yes'/>
            <!-- const std::allocator<void (*)()>& -->
            <return type-id='type-id-572'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::allocator<void (*)()> std::_Vector_base<void (*)(), std::allocator<void (*)()> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt12_Vector_baseIPFvvESaIS1_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-566' is-artificial='yes'/>
            <!-- class std::allocator<void (*)()> -->
            <return type-id='type-id-570'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_base() -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_base(const std::allocator<void (*)()>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<void (*)()>&' -->
            <parameter type-id='type-id-572'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_Vector_base(unsigned long int, const std::allocator<void (*)()>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<void (*)()>&' -->
            <parameter type-id='type-id-572'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::_Vector_base<void (*)(), std::allocator<void (*)()> >::~_Vector_base(int) -->
          <function-decl name='~_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void ()** std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_M_allocate(unsigned long int) -->
          <function-decl name='_M_allocate' mangled-name='_ZNSt12_Vector_baseIPFvvESaIS1_EE11_M_allocateEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<void (*)(), std::allocator<void (*)()> >::_M_deallocate(void ()**, unsigned long int) -->
          <function-decl name='_M_deallocate' mangled-name='_ZNSt12_Vector_baseIPFvvESaIS1_EE13_M_deallocateEPS1_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-673' is-artificial='yes'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<const long unsigned int, HeapLeakChecker::RangeValue> -->
      <class-decl name='pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-607'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- const unsigned long int std::pair<const long unsigned int, HeapLeakChecker::RangeValue>::first -->
          <var-decl name='first' type-id='type-id-633' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- HeapLeakChecker::RangeValue std::pair<const long unsigned int, HeapLeakChecker::RangeValue>::second -->
          <var-decl name='second' type-id='type-id-266' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, HeapLeakChecker::RangeValue>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
            <parameter type-id='type-id-335' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, HeapLeakChecker::RangeValue>::pair(const unsigned long int&, const HeapLeakChecker::RangeValue&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
            <parameter type-id='type-id-335' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- parameter of type 'const HeapLeakChecker::RangeValue&' -->
            <parameter type-id='type-id-432'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const long unsigned int, HeapLeakChecker::RangeValue>::pair<long unsigned int, HeapLeakChecker::RangeValue>(const std::pair<long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='pair&lt;long unsigned int, HeapLeakChecker::RangeValue&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const long unsigned int, HeapLeakChecker::RangeValue>*' -->
            <parameter type-id='type-id-335' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-615'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-701'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>::first -->
          <var-decl name='first' type-id='type-id-526' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>*' -->
            <parameter type-id='type-id-702' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>::pair(const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool>*' -->
            <parameter type-id='type-id-702' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-528'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > -->
      <class-decl name='map&lt;long unsigned int, HeapLeakChecker::RangeValue, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-371'>
        <member-type access='private'>
          <!-- class std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-779'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, std::_Select1st<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-488' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::map(const std::less<long unsigned int>&, const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-332'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::map(const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-599'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::operator=(const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEEaSERKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-599'/>
            <!-- std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-689'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-330'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-763'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-764'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-763'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-764'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapLeakChecker::RangeValue& std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::operator[](const unsigned long int&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEEixERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- HeapLeakChecker::RangeValue& -->
            <return type-id='type-id-397'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapLeakChecker::RangeValue& std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::at(const unsigned long int&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE2atERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- HeapLeakChecker::RangeValue& -->
            <return type-id='type-id-397'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const HeapLeakChecker::RangeValue& std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::at(const unsigned long int&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE2atERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- const HeapLeakChecker::RangeValue& -->
            <return type-id='type-id-432'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool> std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::insert(const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE6insertERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, bool> -->
            <return type-id='type-id-701'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::insert(std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE6insertESt17_Rb_tree_iteratorIS7_ERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>&' -->
            <parameter type-id='type-id-336'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5eraseERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS7_ESC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >' -->
            <parameter type-id='type-id-526'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::swap(std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4swapERSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-689'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::value_compare std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- class std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::value_compare -->
            <return type-id='type-id-779'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4findERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE4findERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE5countERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11lower_boundERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11lower_boundERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11upper_boundERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-526'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11upper_boundERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11equal_rangeERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-690' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-765'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapImN15HeapLeakChecker10RangeValueESt4lessImE13STL_AllocatorISt4pairIKmS1_ENS0_9AllocatorEEE11equal_rangeERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, HeapLeakChecker::RangeValue, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-600' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
            <return type-id='type-id-766'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-703'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>::first -->
          <var-decl name='first' type-id='type-id-530' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>*' -->
            <parameter type-id='type-id-704' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>::pair(const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool>*' -->
            <parameter type-id='type-id-704' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-532'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<long unsigned int>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;long unsigned int&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-699'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<long unsigned int> std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>::first -->
          <var-decl name='first' type-id='type-id-522' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>*' -->
            <parameter type-id='type-id-700' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>::pair(const std::_Rb_tree_iterator<long unsigned int>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<long unsigned int>, bool>*' -->
            <parameter type-id='type-id-700' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-524'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;long unsigned int&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-697'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>::first -->
          <var-decl name='first' type-id='type-id-503' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>*' -->
            <parameter type-id='type-id-698' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>::pair(const std::_Rb_tree_const_iterator<long unsigned int>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool>*' -->
            <parameter type-id='type-id-698' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<long unsigned int>&' -->
            <parameter type-id='type-id-505'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > -->
      <class-decl name='map&lt;long unsigned int, long unsigned int, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-373'>
        <member-type access='private'>
          <!-- class std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-780'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, std::pair<const long unsigned int, long unsigned int>, std::_Select1st<std::pair<const long unsigned int, long unsigned int> >, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-492' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::map(const std::less<long unsigned int>&, const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-364'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::map(const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-602'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::operator=(const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEEaSERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-602'/>
            <!-- std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-691'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-362'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-771'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-772'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-771'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-772'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- unsigned long int& std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::operator[](const unsigned long int&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEEixERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- unsigned long int& -->
            <return type-id='type-id-350'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- unsigned long int& std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::at(const unsigned long int&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE2atERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- unsigned long int& -->
            <return type-id='type-id-350'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const unsigned long int& std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::at(const unsigned long int&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE2atERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- const unsigned long int& -->
            <return type-id='type-id-352'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool> std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::insert(const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE6insertERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, bool> -->
            <return type-id='type-id-703'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::insert(std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, const std::pair<const long unsigned int, long unsigned int>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE6insertESt17_Rb_tree_iteratorIS5_ERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- parameter of type 'const std::pair<const long unsigned int, long unsigned int>&' -->
            <parameter type-id='type-id-368'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS5_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5eraseERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5eraseESt17_Rb_tree_iteratorIS5_ESB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >' -->
            <parameter type-id='type-id-530'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::swap(std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4swapERS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-691'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::value_compare std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- class std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::value_compare -->
            <return type-id='type-id-780'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4findERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE4findERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE5countERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11lower_boundERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11lower_boundERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11upper_boundERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-530'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11upper_boundERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11equal_rangeERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-692' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-773'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapImmSt4lessImE13STL_AllocatorISt4pairIKmmEN15HeapLeakChecker9AllocatorEEE11equal_rangeERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<long unsigned int, long unsigned int, std::less<long unsigned int>, STL_Allocator<std::pair<const long unsigned int, long unsigned int>, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-603' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
            <return type-id='type-id-774'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > -->
      <class-decl name='set&lt;long unsigned int, std::less&lt;long unsigned int&gt;, STL_Allocator&lt;long unsigned int, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='88' column='1' id='type-id-379'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<long unsigned int, long unsigned int, std::_Identity<long unsigned int>, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> > std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-484' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='112' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::set() -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::set(const std::less<long unsigned int>&, const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<long unsigned int>&' -->
            <parameter type-id='type-id-592'/>
            <!-- parameter of type 'const STL_Allocator<long unsigned int, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-348'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::set(const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-620'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::operator=(const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEEaSERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-620'/>
            <!-- std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-707'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='274' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- struct std::less<long unsigned int> -->
            <return type-id='type-id-590'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='282' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- class STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-346'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='300' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-768'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-768'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='361' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='371' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::swap(std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4swapERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='389' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-707'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::insert(const unsigned long int&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6insertERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='408' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, bool> -->
            <return type-id='type-id-697'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::insert(std::_Rb_tree_const_iterator<long unsigned int>, const unsigned long int&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE6insertESt23_Rb_tree_const_iteratorImERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='435' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorImE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='475' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(const unsigned long int&) -->
          <function-decl name='erase' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='490' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5eraseESt23_Rb_tree_const_iteratorImES8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='505' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<long unsigned int>' -->
            <parameter type-id='type-id-503'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='515' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::count(const unsigned long int&) -->
          <function-decl name='count' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE5countERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4findERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='547' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::find(const unsigned long int&) -->
          <function-decl name='find' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE4findERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='551' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11lower_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='568' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::lower_bound(const unsigned long int&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11lower_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11upper_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<long unsigned int> std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::upper_bound(const unsigned long int&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11upper_boundERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='588' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::_Rb_tree_const_iterator<long unsigned int> -->
            <return type-id='type-id-503'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11equal_rangeERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='609' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-708' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-770'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >::equal_range(const unsigned long int&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3setImSt4lessImE13STL_AllocatorImN15HeapLeakChecker9AllocatorEEE11equal_rangeERKm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<long unsigned int, std::less<long unsigned int>, STL_Allocator<long unsigned int, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-621' is-artificial='yes'/>
            <!-- parameter of type 'const unsigned long int&' -->
            <parameter type-id='type-id-352'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > -->
            <return type-id='type-id-770'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > -->
      <class-decl name='map&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;, std::less&lt;std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;, STL_Allocator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-375'>
        <member-type access='private'>
          <!-- class std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-781'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, std::_Select1st<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-496' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::map(const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&, const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-596'/>
            <!-- parameter of type 'const STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-316'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::map(const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-605'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::operator=(const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EEaSERKSH_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-605'/>
            <!-- std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-693'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- class STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> -->
            <return type-id='type-id-314'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-758'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-759'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-758'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-759'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::operator[](const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EEixERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-709'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::at(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE2atERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-709'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::at(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE2atERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-623'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool> std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::insert(const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE6insertERKSF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool> -->
            <return type-id='type-id-705'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::insert(std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE6insertESt17_Rb_tree_iteratorISF_ERKSF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- parameter of type 'const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-320'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5eraseESt17_Rb_tree_iteratorISF_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5eraseERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::erase(std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5eraseESt17_Rb_tree_iteratorISF_ESJ_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >' -->
            <parameter type-id='type-id-534'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::swap(std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4swapERSH_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-693'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- struct std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-594'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::value_compare std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- class std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::value_compare -->
            <return type-id='type-id-781'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::find(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4findERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::find(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE4findERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::count(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE5countERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::lower_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11lower_boundERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::lower_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11lower_boundERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::upper_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11upper_boundERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-534'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::upper_bound(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11upper_boundERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::equal_range(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11equal_rangeERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-694' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-760'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >::equal_range(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapISbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS2_IS8_S4_EESt4lessIS6_ES2_ISt4pairIKS6_SA_ES4_EE11equal_rangeERSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >, std::less<std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > >, STL_Allocator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-606' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
            <return type-id='type-id-761'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::vector<void (*)(), std::allocator<void (*)()> > -->
      <class-decl name='vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt;' size-in-bits='192' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='171' column='1' id='type-id-625'>
        <!-- struct std::_Vector_base<void (*)(), std::allocator<void (*)()> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-564'/>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::vector() -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::vector(const std::allocator<void (*)()>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<void (*)()>&' -->
            <parameter type-id='type-id-572'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::vector(unsigned long int, void ()* const&, const std::allocator<void (*)()>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- parameter of type 'const std::allocator<void (*)()>&' -->
            <parameter type-id='type-id-572'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::vector(const std::vector<void (*)(), std::allocator<void (*)()> >&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >&' -->
            <parameter type-id='type-id-627'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::vector<void (*)(), std::allocator<void (*)()> >::~vector(int) -->
          <function-decl name='~vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<void (*)(), std::allocator<void (*)()> >& std::vector<void (*)(), std::allocator<void (*)()> >::operator=(const std::vector<void (*)(), std::allocator<void (*)()> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt6vectorIPFvvESaIS1_EEaSERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >&' -->
            <parameter type-id='type-id-627'/>
            <!-- std::vector<void (*)(), std::allocator<void (*)()> >& -->
            <return type-id='type-id-711'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::assign(unsigned long int, void ()* const&) -->
          <function-decl name='assign' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE6assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='434' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-782'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-782'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > > std::vector<void (*)(), std::allocator<void (*)()> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
            <return type-id='type-id-783'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > > std::vector<void (*)(), std::allocator<void (*)()> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
            <return type-id='type-id-784'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > > std::vector<void (*)(), std::allocator<void (*)()> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='479' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
            <return type-id='type-id-783'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > > std::vector<void (*)(), std::allocator<void (*)()> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
            <return type-id='type-id-784'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void (*)(), std::allocator<void (*)()> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void (*)(), std::allocator<void (*)()> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='537' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::resize(unsigned long int, void ()*) -->
          <function-decl name='resize' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE6resizeEmS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='552' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()*' -->
            <parameter type-id='type-id-176'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void (*)(), std::allocator<void (*)()> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::vector<void (*)(), std::allocator<void (*)()> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='574' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& std::vector<void (*)(), std::allocator<void (*)()> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSt6vectorIPFvvESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const& std::vector<void (*)(), std::allocator<void (*)()> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void ()* const& -->
            <return type-id='type-id-716'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_range_check(unsigned long int) -->
          <function-decl name='_M_range_check' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE14_M_range_checkEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& std::vector<void (*)(), std::allocator<void (*)()> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const& std::vector<void (*)(), std::allocator<void (*)()> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void ()* const& -->
            <return type-id='type-id-716'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& std::vector<void (*)(), std::allocator<void (*)()> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='679' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const& std::vector<void (*)(), std::allocator<void (*)()> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- void ()* const& -->
            <return type-id='type-id-716'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& std::vector<void (*)(), std::allocator<void (*)()> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const& std::vector<void (*)(), std::allocator<void (*)()> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='703' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- void ()* const& -->
            <return type-id='type-id-716'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()** std::vector<void (*)(), std::allocator<void (*)()> >::data() -->
          <function-decl name='data' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='714' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const* std::vector<void (*)(), std::allocator<void (*)()> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- void ()* const* -->
            <return type-id='type-id-717'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::push_back(void ()* const&) -->
          <function-decl name='push_back' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE9push_backERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='733' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::insert(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, void ()* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::insert(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, unsigned long int, void ()* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::erase(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > std::vector<void (*)(), std::allocator<void (*)()> >::erase(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EES7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::swap(std::vector<void (*)(), std::allocator<void (*)()> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE4swapERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >&' -->
            <parameter type-id='type-id-711'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='950' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_fill_initialize(unsigned long int, void ()* const&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE18_M_fill_initializeEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1033' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_fill_assign(unsigned long int, void ()* const&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE14_M_fill_assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_fill_insert(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, unsigned long int, void ()* const&) -->
          <function-decl name='_M_fill_insert' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_insert_aux(__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >, void ()* const&) -->
          <function-decl name='_M_insert_aux' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt6vectorIPFvvESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >' -->
            <parameter type-id='type-id-413'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- size_t std::vector<void (*)(), std::allocator<void (*)()> >::_M_check_len(unsigned long int, const char*) -->
          <function-decl name='_M_check_len' mangled-name='_ZNKSt6vectorIPFvvESaIS1_EE12_M_check_lenEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-628' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void (*)(), std::allocator<void (*)()> >::_M_erase_at_end(void ()**) -->
          <function-decl name='_M_erase_at_end' mangled-name='_ZNSt6vectorIPFvvESaIS1_EE15_M_erase_at_endEPS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void (*)(), std::allocator<void (*)()> >*' -->
            <parameter type-id='type-id-390' is-artificial='yes'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<void (**)(), false> -->
      <class-decl name='__niter_base&lt;void (**)(), false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-785'>
        <member-function access='public' static='yes'>
          <!-- void ()** std::__niter_base<void (**)(), false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPPFvvELb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<void (**)(), false> -->
      <class-decl name='__miter_base&lt;void (**)(), false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-786'>
        <member-function access='public' static='yes'>
          <!-- void ()** std::__miter_base<void (**)(), false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPPFvvELb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > -->
      <class-decl name='vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt;' size-in-bits='192' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='171' column='1' id='type-id-629'>
        <!-- struct std::_Vector_base<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-567'/>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::vector() -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::vector(const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-169'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::vector(unsigned long int, void* const&, const STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- parameter of type 'const STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
            <parameter type-id='type-id-169'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::vector(const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-631'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::~vector(int) -->
          <function-decl name='~vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::operator=(const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEaSERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-631'/>
            <!-- std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >& -->
            <return type-id='type-id-712'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::assign(unsigned long int, void* const&) -->
          <function-decl name='assign' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6assignEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='434' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-787'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-787'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-788'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-789'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='479' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-788'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-789'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='537' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::resize(unsigned long int, void*) -->
          <function-decl name='resize' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6resizeEmS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='552' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='574' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* const& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_range_check(unsigned long int) -->
          <function-decl name='_M_range_check' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_range_checkEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* const& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='679' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* const& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* const& std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='703' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void** std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::data() -->
          <function-decl name='data' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='714' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* const* std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- void* const* -->
            <return type-id='type-id-173'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::push_back(void* const&) -->
          <function-decl name='push_back' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE9push_backERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='733' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, void* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::insert(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, unsigned long int, void* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE6insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPS0_S5_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::erase(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5eraseEN9__gnu_cxx17__normal_iteratorIPS0_S5_EES9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::swap(std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE4swapERS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-712'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='950' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_fill_initialize(unsigned long int, void* const&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE18_M_fill_initializeEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1033' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_fill_assign(unsigned long int, void* const&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_fill_assignEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_fill_insert(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, unsigned long int, void* const&) -->
          <function-decl name='_M_fill_insert' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPS0_S5_EEmRKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_insert_aux(__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >, void* const&) -->
          <function-decl name='_M_insert_aux' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS0_S5_EERKS0_'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-416'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- size_t std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_check_len(unsigned long int, const char*) -->
          <function-decl name='_M_check_len' mangled-name='_ZNKSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE12_M_check_lenEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-632' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >::_M_erase_at_end(void**) -->
          <function-decl name='_M_erase_at_end' mangled-name='_ZNSt6vectorIPv13STL_AllocatorIS0_N15HeapLeakChecker9AllocatorEEE15_M_erase_at_endEPS0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> >*' -->
            <parameter type-id='type-id-713' is-artificial='yes'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<AllocObject*, false> -->
      <class-decl name='__niter_base&lt;AllocObject*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-790'>
        <member-function access='public' static='yes'>
          <!-- AllocObject* std::__niter_base<AllocObject*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIP11AllocObjectLb0EE3__bES1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<AllocObject*, false> -->
      <class-decl name='__miter_base&lt;AllocObject*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-791'>
        <member-function access='public' static='yes'>
          <!-- AllocObject* std::__miter_base<AllocObject*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIP11AllocObjectLb0EE3__bES1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-507'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-329'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-528'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-510' is-artificial='yes'/>
            <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>& -->
            <return type-id='type-id-336'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-510' is-artificial='yes'/>
            <!-- const std::pair<const long unsigned int, HeapLeakChecker::RangeValue>* -->
            <return type-id='type-id-337'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
            <return type-id='type-id-654'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >& -->
            <return type-id='type-id-654'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-655' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
            <return type-id='type-id-507'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator==(const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEeqERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-510' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-509'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >::operator!=(const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmN15HeapLeakChecker10RangeValueEEEneERKS5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >*' -->
            <parameter type-id='type-id-510' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >&' -->
            <parameter type-id='type-id-509'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__copy_move<false, false, std::random_access_iterator_tag> -->
      <class-decl name='__copy_move&lt;false, false, std::random_access_iterator_tag&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='335' column='1' id='type-id-792'>
        <member-function access='public' static='yes'>
          <!-- AllocObject* std::__copy_move<false, false, std::random_access_iterator_tag>::__copy_m<AllocObject*, AllocObject*>(AllocObject*, AllocObject*) -->
          <function-decl name='__copy_m&lt;AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='338' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- parameter of type 'AllocObject*' -->
            <parameter type-id='type-id-156'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, true> -->
      <class-decl name='__niter_base&lt;__gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, true&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-793'>
        <member-function access='public' static='yes'>
          <!-- AllocObject* std::__niter_base<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, true>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS2_13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEEEELb1EE3__bESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, false> -->
      <class-decl name='__miter_base&lt;__gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-794'>
        <member-function access='public' static='yes'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::__miter_base<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS2_13STL_AllocatorIS2_N15HeapLeakChecker9AllocatorEEEEELb0EE3__bESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
            <parameter type-id='type-id-407'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
      <class-decl name='pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='256' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-611'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::first -->
          <var-decl name='first' type-id='type-id-574' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::second -->
          <var-decl name='second' type-id='type-id-377' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-319' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::pair(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-319' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-575'/>
            <!-- parameter of type 'const std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >&' -->
            <parameter type-id='type-id-623'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-511'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-361'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-532'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const long unsigned int, long unsigned int>& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmmEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-514' is-artificial='yes'/>
            <!-- const std::pair<const long unsigned int, long unsigned int>& -->
            <return type-id='type-id-368'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const long unsigned int, long unsigned int>* std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmmEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-514' is-artificial='yes'/>
            <!-- const std::pair<const long unsigned int, long unsigned int>* -->
            <return type-id='type-id-369'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmmEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
            <return type-id='type-id-656'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmmEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmmEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >& -->
            <return type-id='type-id-656'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKmmEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-657' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > -->
            <return type-id='type-id-511'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator==(const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmmEEeqERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-514' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-513'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >::operator!=(const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKmmEEneERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >*' -->
            <parameter type-id='type-id-514' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >&' -->
            <parameter type-id='type-id-513'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-705'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>::first -->
          <var-decl name='first' type-id='type-id-534' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>*' -->
            <parameter type-id='type-id-706' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>::pair(const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, bool>*' -->
            <parameter type-id='type-id-706' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-536'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-515'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-313'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-536'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-518' is-artificial='yes'/>
            <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-320'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-518' is-artificial='yes'/>
            <!-- const std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >* -->
            <return type-id='type-id-321'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
            <return type-id='type-id-658'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >& -->
            <return type-id='type-id-658'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-659' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
            <return type-id='type-id-515'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator==(const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEeqERKSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-518' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-517'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >::operator!=(const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKSbIcSt11char_traitsIcE13STL_AllocatorIcN15HeapLeakChecker9AllocatorEEESt6vectorI11AllocObjectS3_ISA_S5_EEEEneERKSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >*' -->
            <parameter type-id='type-id-518' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >&' -->
            <parameter type-id='type-id-517'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- void std::swap<AllocObject*>(AllocObject*&, AllocObject*&) -->
      <function-decl name='swap&lt;AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/move.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*&' -->
        <parameter type-id='type-id-394'/>
        <!-- parameter of type 'AllocObject*&' -->
        <parameter type-id='type-id-394'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::_Destroy<AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >(AllocObject*, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
      <function-decl name='_Destroy&lt;AllocObject*, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-400'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::_Destroy<void (**)()>(void ()**, void ()**) -->
      <function-decl name='_Destroy&lt;void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- std::random_access_iterator_tag std::__iterator_category<const char*>(const char* const&) -->
      <function-decl name='__iterator_category&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_types.h' line='160' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const char* const&' -->
        <parameter type-id='type-id-479'/>
        <!-- struct std::random_access_iterator_tag -->
        <return type-id='type-id-732'/>
      </function-decl>
      <!-- ptrdiff_t std::__distance<const char*>(const char*, const char*, std::random_access_iterator_tag) -->
      <function-decl name='__distance&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_funcs.h' line='87' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- parameter of type 'struct std::random_access_iterator_tag' -->
        <parameter type-id='type-id-732'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- AllocObject* std::__uninitialized_copy_a<AllocObject*, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >(AllocObject*, AllocObject*, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
      <function-decl name='__uninitialized_copy_a&lt;AllocObject*, AllocObject*, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='235' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-400'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- void std::_Destroy<void**, STL_Allocator<void*, HeapLeakChecker::Allocator> >(void**, void**, STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
      <function-decl name='_Destroy&lt;void**, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-405'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void** std::__uninitialized_copy_a<void**, void**, STL_Allocator<void*, HeapLeakChecker::Allocator> >(void**, void**, void**, STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
      <function-decl name='__uninitialized_copy_a&lt;void**, void**, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='235' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-405'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- std::pair<long unsigned int, HeapLeakChecker::RangeValue> std::make_pair<long unsigned int, HeapLeakChecker::RangeValue>(unsigned long int, HeapLeakChecker::RangeValue) -->
      <function-decl name='make_pair&lt;long unsigned int, HeapLeakChecker::RangeValue&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'unsigned long int' -->
        <parameter type-id='type-id-5'/>
        <!-- parameter of type 'struct HeapLeakChecker::RangeValue' -->
        <parameter type-id='type-id-266'/>
        <!-- struct std::pair<long unsigned int, HeapLeakChecker::RangeValue> -->
        <return type-id='type-id-613'/>
      </function-decl>
      <!-- AllocObject* std::__uninitialized_copy_a<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >(__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
      <function-decl name='__uninitialized_copy_a&lt;__gnu_cxx::__normal_iterator&lt;const AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, AllocObject*, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='235' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-410'/>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-410'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-400'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- void std::_Destroy<void (**)(), void (*)()>(void ()**, void ()**, std::allocator<void (*)()>&) -->
      <function-decl name='_Destroy&lt;void (**)(), void (*)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'std::allocator<void (*)()>&' -->
        <parameter type-id='type-id-679'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- bool std::operator==<char, std::char_traits<char>, std::allocator<char> >(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, const char*) -->
      <function-decl name='operator==&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2265' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
        <parameter type-id='type-id-795'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void ()** std::__copy_move_backward_a<false, void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='__copy_move_backward_a&lt;false, void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::__copy_move_backward_a2<false, void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='__copy_move_backward_a2&lt;false, void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::__copy_move_a<false, void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='__copy_move_a&lt;false, void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::__copy_move_a2<false, void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='__copy_move_a2&lt;false, void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::copy<void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='copy&lt;void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::uninitialized_copy<void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='uninitialized_copy&lt;void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void ()** std::__uninitialized_copy_a<void (**)(), void (**)(), void (*)()>(void ()**, void ()**, void ()**, std::allocator<void (*)()>&) -->
      <function-decl name='__uninitialized_copy_a&lt;void (**)(), void (**)(), void (*)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='254' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'std::allocator<void (*)()>&' -->
        <parameter type-id='type-id-679'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- void** std::__copy_move_backward_a<false, void**, void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_backward_a&lt;false, void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::__copy_move_backward_a2<false, void**, void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_backward_a2&lt;false, void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- const size_t& std::max<size_t>(const size_t&, const size_t&) -->
      <function-decl name='max&lt;size_t&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const size_t&' -->
        <parameter type-id='type-id-480'/>
        <!-- parameter of type 'const size_t&' -->
        <parameter type-id='type-id-480'/>
        <!-- const size_t& -->
        <return type-id='type-id-480'/>
      </function-decl>
      <!-- void** std::copy_backward<void**, void**>(void**, void**, void**) -->
      <function-decl name='copy_backward&lt;void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::__uninitialized_move_a<void**, void**, STL_Allocator<void*, HeapLeakChecker::Allocator> >(void**, void**, void**, STL_Allocator<void*, HeapLeakChecker::Allocator>&) -->
      <function-decl name='__uninitialized_move_a&lt;void**, void**, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='261' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'STL_Allocator<void*, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-405'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void ()** std::copy_backward<void (**)(), void (**)()>(void ()**, void ()**, void ()**) -->
      <function-decl name='copy_backward&lt;void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- std::pair<long unsigned int, long unsigned int> std::make_pair<long unsigned int, long unsigned int>(unsigned long int, unsigned long int) -->
      <function-decl name='make_pair&lt;long unsigned int, long unsigned int&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'unsigned long int' -->
        <parameter type-id='type-id-5'/>
        <!-- parameter of type 'unsigned long int' -->
        <parameter type-id='type-id-5'/>
        <!-- struct std::pair<long unsigned int, long unsigned int> -->
        <return type-id='type-id-616'/>
      </function-decl>
      <!-- AllocObject* std::__copy_move_backward_a<false, AllocObject*, AllocObject*>(AllocObject*, AllocObject*, AllocObject*) -->
      <function-decl name='__copy_move_backward_a&lt;false, AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- AllocObject* std::__copy_move_backward_a2<false, AllocObject*, AllocObject*>(AllocObject*, AllocObject*, AllocObject*) -->
      <function-decl name='__copy_move_backward_a2&lt;false, AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- AllocObject* std::copy_backward<AllocObject*, AllocObject*>(AllocObject*, AllocObject*, AllocObject*) -->
      <function-decl name='copy_backward&lt;AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- AllocObject* std::__uninitialized_move_a<AllocObject*, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> >(AllocObject*, AllocObject*, AllocObject*, STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&) -->
      <function-decl name='__uninitialized_move_a&lt;AllocObject*, AllocObject*, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='261' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'STL_Allocator<AllocObject, HeapLeakChecker::Allocator>&' -->
        <parameter type-id='type-id-400'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- AllocObject* std::__copy_move_a<false, AllocObject*, AllocObject*>(AllocObject*, AllocObject*, AllocObject*) -->
      <function-decl name='__copy_move_a&lt;false, AllocObject*, AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- parameter of type 'AllocObject*' -->
        <parameter type-id='type-id-156'/>
        <!-- AllocObject* -->
        <return type-id='type-id-156'/>
      </function-decl>
      <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::__copy_move_a2<false, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >) -->
      <function-decl name='__copy_move_a2&lt;false, __gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, __gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
        <return type-id='type-id-407'/>
      </function-decl>
      <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > std::copy<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >(__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >, __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >) -->
      <function-decl name='copy&lt;__gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;, __gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- parameter of type 'class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >' -->
        <parameter type-id='type-id-407'/>
        <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
        <return type-id='type-id-407'/>
      </function-decl>
      <!-- ptrdiff_t std::distance<const char*>(const char*, const char*) -->
      <function-decl name='distance&lt;const char*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator_base_funcs.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- const size_t& std::min<size_t>(const size_t&, const size_t&) -->
      <function-decl name='min&lt;size_t&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const size_t&' -->
        <parameter type-id='type-id-480'/>
        <!-- parameter of type 'const size_t&' -->
        <parameter type-id='type-id-480'/>
        <!-- const size_t& -->
        <return type-id='type-id-480'/>
      </function-decl>
      <!-- bool std::operator< <char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >(const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&, const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&) -->
      <function-decl name='operator&lt; &lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2315' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
        <parameter type-id='type-id-575'/>
        <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >&' -->
        <parameter type-id='type-id-575'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- bool std::operator!=<char, std::char_traits<char>, std::allocator<char> >(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, const char*) -->
      <function-decl name='operator!=&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2302' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
        <parameter type-id='type-id-795'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, const char*) -->
      <function-decl name='operator+&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;' mangled-name='_ZStplIcSt11char_traitsIcESaIcEESbIT_T0_T1_ERKS6_PKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2198' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZStplIcSt11char_traitsIcESaIcEESbIT_T0_T1_ERKS6_PKS3_'>
        <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
        <parameter type-id='type-id-795'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
        <return type-id='type-id-796'/>
      </function-decl>
      <!-- void ()** std::__uninitialized_move_a<void (**)(), void (**)(), std::allocator<void (*)()> >(void ()**, void ()**, void ()**, std::allocator<void (*)()>&) -->
      <function-decl name='__uninitialized_move_a&lt;void (**)(), void (**)(), std::allocator&lt;void (*)()&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='261' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'void ()**' -->
        <parameter type-id='type-id-719'/>
        <!-- parameter of type 'std::allocator<void (*)()>&' -->
        <parameter type-id='type-id-679'/>
        <!-- void ()** -->
        <return type-id='type-id-719'/>
      </function-decl>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-751'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-752'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-755'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-756'/>
      <!-- struct std::_Rb_tree_node<long unsigned int> -->
      <class-decl name='_Rb_tree_node&lt;long unsigned int&gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-541'/>
      <!-- struct std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-547'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-758'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-759'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-760'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > >, std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> >, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;const std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt;, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-761'/>
      <!-- struct std::_Rb_tree_node<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-543'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-763'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-764'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-765'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, HeapLeakChecker::RangeValue> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, HeapLeakChecker::RangeValue&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-766'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<long unsigned int> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;long unsigned int&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-767'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<long unsigned int> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;long unsigned int&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-768'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<long unsigned int>, std::_Rb_tree_iterator<long unsigned int> > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;long unsigned int&gt;, std::_Rb_tree_iterator&lt;long unsigned int&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-769'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<long unsigned int>, std::_Rb_tree_const_iterator<long unsigned int> > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;long unsigned int&gt;, std::_Rb_tree_const_iterator&lt;long unsigned int&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-770'/>
      <!-- struct std::_Rb_tree_node<std::pair<const long unsigned int, long unsigned int> > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-545'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-771'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-772'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-773'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> >, std::_Rb_tree_const_iterator<std::pair<const long unsigned int, long unsigned int> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;const long unsigned int, long unsigned int&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-774'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;void (**)(), std::vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-783'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;void (* const*)(), std::vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-784'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;void**, std::vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-788'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;void* const*, std::vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-789'/>
      <!-- struct std::_Rb_tree_node<MemoryRegionMap::Region> -->
      <class-decl name='_Rb_tree_node&lt;MemoryRegionMap::Region&gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-538'/>
    </namespace-decl>
    <!-- namespace __gnu_cxx -->
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;const AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-410'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- const AllocObject* __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-163' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::__normal_iterator(const AllocObject* const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'const AllocObject* const&' -->
            <parameter type-id='type-id-428'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject* __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- const AllocObject* -->
            <return type-id='type-id-163'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-411'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-411'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- const AllocObject& -->
            <return type-id='type-id-162'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-411'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-411'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const AllocObject* const& __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPK11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-463' is-artificial='yes'/>
            <!-- const AllocObject* const& -->
            <return type-id='type-id-428'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::__normal_iterator<AllocObject*>(const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
          <function-decl name='__normal_iterator&lt;AllocObject*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='690' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-412' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
            <parameter type-id='type-id-459'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-407'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- AllocObject* __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-156' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::__normal_iterator(AllocObject* const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- parameter of type 'AllocObject* const&' -->
            <parameter type-id='type-id-393'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject* __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- AllocObject* -->
            <return type-id='type-id-156'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-408'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-408'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- AllocObject& -->
            <return type-id='type-id-161'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-408'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-409' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-408'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-407'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- AllocObject* const& __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIP11AllocObjectSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-460' is-artificial='yes'/>
            <!-- AllocObject* const& -->
            <return type-id='type-id-393'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;void**, std::vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-416'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- void** __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-141' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::__normal_iterator(void** const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- parameter of type 'void** const&' -->
            <parameter type-id='type-id-731'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void** __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-417'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-417'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void*& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- void*& -->
            <return type-id='type-id-171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-417'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-418' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >& -->
            <return type-id='type-id-417'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
            <return type-id='type-id-416'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void** const& __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPvSt6vectorIS1_13STL_AllocatorIS1_N15HeapLeakChecker9AllocatorEEEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >*' -->
            <parameter type-id='type-id-469' is-artificial='yes'/>
            <!-- void** const& -->
            <return type-id='type-id-731'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
      <class-decl name='__normal_iterator&lt;void (**)(), std::vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-413'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- void ()** __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-719' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::__normal_iterator(void ()** const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- parameter of type 'void ()** const&' -->
            <parameter type-id='type-id-721'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()** __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
            <return type-id='type-id-414'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
            <return type-id='type-id-414'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()*& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- void ()*& -->
            <return type-id='type-id-718'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
            <return type-id='type-id-414'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-415' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >& -->
            <return type-id='type-id-414'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
            <return type-id='type-id-413'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()** const& __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPPFvvESt6vectorIS2_SaIS2_EEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >*' -->
            <parameter type-id='type-id-466' is-artificial='yes'/>
            <!-- void ()** const& -->
            <return type-id='type-id-721'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<void (*)()> -->
      <class-decl name='new_allocator&lt;void (*)()&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-419'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<void (*)()>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<void (*)()>::new_allocator(const __gnu_cxx::new_allocator<void (*)()>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<void (*)()>&' -->
            <parameter type-id='type-id-471'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<void (*)()>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()** __gnu_cxx::new_allocator<void (*)()>::address(void ()*&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIPFvvEE7addressERS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-472' is-artificial='yes'/>
            <!-- parameter of type 'void ()*&' -->
            <parameter type-id='type-id-718'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()* const* __gnu_cxx::new_allocator<void (*)()>::address(void ()* const&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIPFvvEE7addressERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-472' is-artificial='yes'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void ()* const* -->
            <return type-id='type-id-717'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void ()** __gnu_cxx::new_allocator<void (*)()>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIPFvvEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<void (*)()>::deallocate(void ()**, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIPFvvEE10deallocateEPS2_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<void (*)()>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIPFvvEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-472' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<void (*)()>::construct(void ()**, void ()* const&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIPFvvEE9constructEPS2_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'void ()* const&' -->
            <parameter type-id='type-id-716'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<void (*)()>::destroy(void ()**) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIPFvvEE7destroyEPS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<void (*)()>*' -->
            <parameter type-id='type-id-420' is-artificial='yes'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- bool __gnu_cxx::operator==<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator==&lt;const AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='771' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-462'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-462'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- bool __gnu_cxx::operator!=<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator!=&lt;const AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='783' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-462'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-462'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- ptrdiff_t __gnu_cxx::operator&#45;<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator-&lt;void**, std::vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='856' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-468'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<void**, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-468'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- ptrdiff_t __gnu_cxx::operator&#45;<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >(const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >&, const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >&) -->
      <function-decl name='operator-&lt;void (**)(), std::vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='856' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >&' -->
        <parameter type-id='type-id-465'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<void (**)(), std::vector<void (*)(), std::allocator<void (*)()> > >&' -->
        <parameter type-id='type-id-465'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- ptrdiff_t __gnu_cxx::operator&#45;<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator-&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='856' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-459'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-459'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- bool __gnu_cxx::operator!=<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator!=&lt;AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='783' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-459'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-459'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- bool __gnu_cxx::operator!=<const AllocObject*, AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >(const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&, const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&) -->
      <function-decl name='operator!=&lt;const AllocObject*, AllocObject*, std::vector&lt;AllocObject, STL_Allocator&lt;AllocObject, HeapLeakChecker::Allocator&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='777' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<const AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-462'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<AllocObject*, std::vector<AllocObject, STL_Allocator<AllocObject, HeapLeakChecker::Allocator> > >&' -->
        <parameter type-id='type-id-459'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- bool __gnu_cxx::__is_null_pointer<const char>(const char*) -->
      <function-decl name='__is_null_pointer&lt;const char&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/type_traits.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-749'/>
      <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, STL_Allocator<char, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, STL_Allocator&lt;char, HeapLeakChecker::Allocator&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-750'/>
      <!-- class __gnu_cxx::__normal_iterator<void (* const*)(), std::vector<void (*)(), std::allocator<void (*)()> > > -->
      <class-decl name='__normal_iterator&lt;void (* const*)(), std::vector&lt;void (*)(), std::allocator&lt;void (*)()&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-782'/>
      <!-- class __gnu_cxx::__normal_iterator<void* const*, std::vector<void*, STL_Allocator<void*, HeapLeakChecker::Allocator> > > -->
      <class-decl name='__normal_iterator&lt;void* const*, std::vector&lt;void*, STL_Allocator&lt;void*, HeapLeakChecker::Allocator&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-787'/>
    </namespace-decl>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- namespace base::internal -->
      <namespace-decl name='internal'>
        <!-- struct base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)> -->
        <class-decl name='HookList&lt;void (*)(const void*, const void*, size_t, int, int, int, off_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-421'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::Add(void (void*, void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_miiilEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-422' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-384'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_miiilEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-422' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::Remove(void (void*, void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_miiilEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-422' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-384'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::Traverse(void (void*, void*, typedef size_t, int, int, int, typedef off_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_miiilEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-474' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, int, int, int, typedef off_t)**' -->
              <parameter type-id='type-id-728'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_miiilEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-474' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)* base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_miiilEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-474' is-artificial='yes'/>
              <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)* -->
              <return type-id='type-id-384'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)* base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>::ExchangeSingular(void (void*, void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_miiilEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-422' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-384'/>
              <!-- void (void*, void*, typedef size_t, int, int, int, typedef off_t)* -->
              <return type-id='type-id-384'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<void (*)(const void*, ptrdiff_t)> -->
        <class-decl name='HookList&lt;void (*)(const void*, ptrdiff_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-423'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, ptrdiff_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, ptrdiff_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, ptrdiff_t)>::Add(void (void*, typedef ptrdiff_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvlEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-424' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-386'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, ptrdiff_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvlEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-424' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, ptrdiff_t)>::Remove(void (void*, typedef ptrdiff_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvlEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-424' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-386'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, ptrdiff_t)>::Traverse(void (void*, typedef ptrdiff_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvlEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-476' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef ptrdiff_t)**' -->
              <parameter type-id='type-id-726'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, ptrdiff_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvlEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-476' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef ptrdiff_t)* base::internal::HookList<void (*)(const void*, ptrdiff_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvlEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-476' is-artificial='yes'/>
              <!-- void (void*, typedef ptrdiff_t)* -->
              <return type-id='type-id-386'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef ptrdiff_t)* base::internal::HookList<void (*)(const void*, ptrdiff_t)>::ExchangeSingular(void (void*, typedef ptrdiff_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvlEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, ptrdiff_t)>*' -->
              <parameter type-id='type-id-424' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-386'/>
              <!-- void (void*, typedef ptrdiff_t)* -->
              <return type-id='type-id-386'/>
            </function-decl>
          </member-function>
        </class-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead'>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_pointer_source_alignment -->
      <var-decl name='FLAGS_heap_check_pointer_source_alignment' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead41FLAGS_heap_check_pointer_source_alignmentE' visibility='default' filepath='src/heap-checker.cc' line='190' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead41FLAGS_heap_check_pointer_source_alignmentE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_pointer_source_alignment -->
      <var-decl name='FLAGS_noheap_check_pointer_source_alignment' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead43FLAGS_noheap_check_pointer_source_alignmentE' visibility='default' filepath='src/heap-checker.cc' line='194' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead43FLAGS_noheap_check_pointer_source_alignmentE'/>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_delay_seconds -->
      <var-decl name='FLAGS_heap_check_delay_seconds' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead30FLAGS_heap_check_delay_secondsE' visibility='default' filepath='src/heap-checker.cc' line='216' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead30FLAGS_heap_check_delay_secondsE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_delay_seconds -->
      <var-decl name='FLAGS_noheap_check_delay_seconds' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead32FLAGS_noheap_check_delay_secondsE' visibility='default' filepath='src/heap-checker.cc' line='225' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead32FLAGS_noheap_check_delay_secondsE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead'>
      <!-- std::string FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_check -->
      <var-decl name='FLAGS_heap_check' type-id='type-id-800' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead16FLAGS_heap_checkE' visibility='default' filepath='src/heap-checker.cc' line='142' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead16FLAGS_heap_checkE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_check -->
      <var-decl name='FLAGS_noheap_check' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead18FLAGS_noheap_checkE' visibility='default' filepath='src/heap-checker.cc' line='148' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead18FLAGS_noheap_checkE'/>
      <!-- std::string FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_profile_pprof -->
      <var-decl name='FLAGS_heap_profile_pprof' type-id='type-id-800' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead24FLAGS_heap_profile_pprofE' visibility='default' filepath='src/heap-checker.cc' line='229' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead24FLAGS_heap_profile_pprofE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_profile_pprof -->
      <var-decl name='FLAGS_noheap_profile_pprof' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead26FLAGS_noheap_profile_pprofE' visibility='default' filepath='src/heap-checker.cc' line='231' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead26FLAGS_noheap_profile_pprofE'/>
      <!-- std::string FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_heap_check_dump_directory -->
      <var-decl name='FLAGS_heap_check_dump_directory' type-id='type-id-800' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead31FLAGS_heap_check_dump_directoryE' visibility='default' filepath='src/heap-checker.cc' line='233' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead31FLAGS_heap_check_dump_directoryE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_noheap_check_dump_directory -->
      <var-decl name='FLAGS_noheap_check_dump_directory' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead33FLAGS_noheap_check_dump_directoryE' visibility='default' filepath='src/heap-checker.cc' line='235' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead33FLAGS_noheap_check_dump_directoryE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_report -->
      <var-decl name='FLAGS_heap_check_report' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_heap_check_reportE' visibility='default' filepath='src/heap-checker.cc' line='150' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_heap_check_reportE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_report -->
      <var-decl name='FLAGS_noheap_check_report' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noheap_check_reportE' visibility='default' filepath='src/heap-checker.cc' line='150' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noheap_check_reportE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_before_constructors -->
      <var-decl name='FLAGS_heap_check_before_constructors' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_heap_check_before_constructorsE' visibility='default' filepath='src/heap-checker.cc' line='152' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_heap_check_before_constructorsE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_before_constructors -->
      <var-decl name='FLAGS_noheap_check_before_constructors' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead38FLAGS_noheap_check_before_constructorsE' visibility='default' filepath='src/heap-checker.cc' line='154' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead38FLAGS_noheap_check_before_constructorsE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_after_destructors -->
      <var-decl name='FLAGS_heap_check_after_destructors' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_heap_check_after_destructorsE' visibility='default' filepath='src/heap-checker.cc' line='156' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_heap_check_after_destructorsE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_after_destructors -->
      <var-decl name='FLAGS_noheap_check_after_destructors' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_noheap_check_after_destructorsE' visibility='default' filepath='src/heap-checker.cc' line='159' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead36FLAGS_noheap_check_after_destructorsE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_strict_check -->
      <var-decl name='FLAGS_heap_check_strict_check' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_heap_check_strict_checkE' visibility='default' filepath='src/heap-checker.cc' line='161' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_heap_check_strict_checkE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_strict_check -->
      <var-decl name='FLAGS_noheap_check_strict_check' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_noheap_check_strict_checkE' visibility='default' filepath='src/heap-checker.cc' line='161' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_noheap_check_strict_checkE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_ignore_global_live -->
      <var-decl name='FLAGS_heap_check_ignore_global_live' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_global_liveE' visibility='default' filepath='src/heap-checker.cc' line='163' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_global_liveE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_ignore_global_live -->
      <var-decl name='FLAGS_noheap_check_ignore_global_live' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_global_liveE' visibility='default' filepath='src/heap-checker.cc' line='166' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_global_liveE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_identify_leaks -->
      <var-decl name='FLAGS_heap_check_identify_leaks' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_heap_check_identify_leaksE' visibility='default' filepath='src/heap-checker.cc' line='168' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_heap_check_identify_leaksE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_identify_leaks -->
      <var-decl name='FLAGS_noheap_check_identify_leaks' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_noheap_check_identify_leaksE' visibility='default' filepath='src/heap-checker.cc' line='173' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_noheap_check_identify_leaksE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_ignore_thread_live -->
      <var-decl name='FLAGS_heap_check_ignore_thread_live' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_thread_liveE' visibility='default' filepath='src/heap-checker.cc' line='175' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_heap_check_ignore_thread_liveE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_ignore_thread_live -->
      <var-decl name='FLAGS_noheap_check_ignore_thread_live' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_thread_liveE' visibility='default' filepath='src/heap-checker.cc' line='178' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_noheap_check_ignore_thread_liveE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_test_pointer_alignment -->
      <var-decl name='FLAGS_heap_check_test_pointer_alignment' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead39FLAGS_heap_check_test_pointer_alignmentE' visibility='default' filepath='src/heap-checker.cc' line='180' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead39FLAGS_heap_check_test_pointer_alignmentE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_test_pointer_alignment -->
      <var-decl name='FLAGS_noheap_check_test_pointer_alignment' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead41FLAGS_noheap_check_test_pointer_alignmentE' visibility='default' filepath='src/heap-checker.cc' line='183' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead41FLAGS_noheap_check_test_pointer_alignmentE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_heap_check_run_under_gdb -->
      <var-decl name='FLAGS_heap_check_run_under_gdb' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_heap_check_run_under_gdbE' visibility='default' filepath='src/heap-checker.cc' line='211' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_heap_check_run_under_gdbE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noheap_check_run_under_gdb -->
      <var-decl name='FLAGS_noheap_check_run_under_gdb' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_noheap_check_run_under_gdbE' visibility='default' filepath='src/heap-checker.cc' line='214' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_noheap_check_run_under_gdbE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_check_max_pointer_offset -->
      <var-decl name='FLAGS_heap_check_max_pointer_offset' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_heap_check_max_pointer_offsetE' visibility='default' filepath='src/heap-checker.cc' line='204' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_heap_check_max_pointer_offsetE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_check_max_pointer_offset -->
      <var-decl name='FLAGS_noheap_check_max_pointer_offset' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead37FLAGS_noheap_check_max_pointer_offsetE' visibility='default' filepath='src/heap-checker.cc' line='209' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead37FLAGS_noheap_check_max_pointer_offsetE'/>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- namespace tcmalloc::commandlineflags -->
      <namespace-decl name='commandlineflags'>
        <!-- int tcmalloc::commandlineflags::StringToInt(const char*, int) -->
        <function-decl name='StringToInt' filepath='./src/base/commandlineflags.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
        <!-- bool tcmalloc::commandlineflags::StringToBool(const char*, bool) -->
        <function-decl name='StringToBool' mangled-name='_ZN8tcmalloc16commandlineflags12StringToBoolEPKcb' filepath='./src/base/commandlineflags.h' line='118' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc16commandlineflags12StringToBoolEPKcb'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'bool' -->
          <parameter type-id='type-id-55'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- void LogPrintf(int, const char*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='LogPrintf' mangled-name='_Z9LogPrintfiPKcP13__va_list_tag' filepath='./src/base/logging.h' line='198' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z9LogPrintfiPKcP13__va_list_tag'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='severity' filepath='./src/base/logging.h' line='198' column='1'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='pat' filepath='./src/base/logging.h' line='198' column='1'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67' name='ap' filepath='./src/base/logging.h' line='198' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void RAW_VLOG(int, const char*, ...) -->
    <function-decl name='RAW_VLOG' mangled-name='_Z8RAW_VLOGiPKcz' filepath='./src/base/logging.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z8RAW_VLOGiPKcz'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='lvl' filepath='./src/base/logging.h' line='229' column='1'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='pat' filepath='./src/base/logging.h' line='229' column='1'/>
      <parameter is-variadic='yes'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void RAW_LOG(int, const char*, ...) -->
    <function-decl name='RAW_LOG' mangled-name='_Z7RAW_LOGiPKcz' filepath='./src/base/logging.h' line='228' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z7RAW_LOGiPKcz'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='lvl' filepath='./src/base/logging.h' line='229' column='1'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='pat' filepath='./src/base/logging.h' line='229' column='1'/>
      <parameter is-variadic='yes'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void HeapLeakChecker_BeforeConstructors() -->
    <function-decl name='HeapLeakChecker_BeforeConstructors' mangled-name='_Z34HeapLeakChecker_BeforeConstructorsv' filepath='src/heap-checker.cc' line='2259' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z34HeapLeakChecker_BeforeConstructorsv'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void MallocHook_InitAtFirstAllocation_HeapLeakChecker() -->
    <function-decl name='MallocHook_InitAtFirstAllocation_HeapLeakChecker' mangled-name='MallocHook_InitAtFirstAllocation_HeapLeakChecker' filepath='src/heap-checker.cc' line='2306' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_InitAtFirstAllocation_HeapLeakChecker'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void HeapLeakChecker_InternalInitStart() -->
    <function-decl name='HeapLeakChecker_InternalInitStart' mangled-name='_Z33HeapLeakChecker_InternalInitStartv' filepath='src/heap-checker.cc' line='1954' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z33HeapLeakChecker_InternalInitStartv'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void HeapLeakChecker_AfterDestructors() -->
    <function-decl name='HeapLeakChecker_AfterDestructors' mangled-name='_Z32HeapLeakChecker_AfterDestructorsv' filepath='src/heap-checker.cc' line='2311' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z32HeapLeakChecker_AfterDestructorsv'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void HeapLeakChecker_RunHeapCleanups() -->
    <function-decl name='HeapLeakChecker_RunHeapCleanups' mangled-name='_Z31HeapLeakChecker_RunHeapCleanupsv' filepath='src/heap-checker.cc' line='1931' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z31HeapLeakChecker_RunHeapCleanupsv'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- AtomicWord[8] -->
    <array-type-def dimensions='1' type-id='type-id-798' size-in-bits='512' id='type-id-799'>
      <!-- <anonymous range>[8] -->
      <subrange length='8' type-id='type-id-5' id='type-id-801'/>
    </array-type-def>
    <!-- HeapProfileBucket** -->
    <pointer-type-def type-id='type-id-205' size-in-bits='64' id='type-id-200'/>
    <!-- HeapProfileBucket[20] -->
    <array-type-def dimensions='1' type-id='type-id-212' size-in-bits='8960' id='type-id-201'>
      <!-- <anonymous range>[20] -->
      <subrange length='20' type-id='type-id-5' id='type-id-802'/>
    </array-type-def>
    <!-- HeapProfileTable::Snapshot::Entry* -->
    <pointer-type-def type-id='type-id-221' size-in-bits='64' id='type-id-222'/>
    <!-- MallocExtension* -->
    <pointer-type-def type-id='type-id-803' size-in-bits='64' id='type-id-278'/>
    <!-- MemoryRegionMap::Region& -->
    <reference-type-def kind='lvalue' type-id='type-id-184' size-in-bits='64' id='type-id-744'/>
    <!-- MemoryRegionMap::RegionSet* -->
    <pointer-type-def type-id='type-id-188' size-in-bits='64' id='type-id-193'/>
    <!-- MemoryRegionMap::RegionSetRep* -->
    <pointer-type-def type-id='type-id-190' size-in-bits='64' id='type-id-192'/>
    <!-- char& -->
    <reference-type-def kind='lvalue' type-id='type-id-60' size-in-bits='64' id='type-id-302'/>
    <!-- char[48] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='384' id='type-id-191'>
      <!-- <anonymous range>[48] -->
      <subrange length='48' type-id='type-id-5' id='type-id-804'/>
    </array-type-def>
    <namespace-decl name='std'>
      <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='map&lt;HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less&lt;HeapProfileTable::Bucket*&gt;, std::allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-226'>
        <member-type access='private'>
          <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-805'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-806' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
            <parameter type-id='type-id-808'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map(const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-810'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator=(const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEEaSERKSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-810'/>
            <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-811'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-813'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator[](HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEEixERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-819'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::at(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE2atERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-819'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::at(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE2atERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- const HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-224'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::insert(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6insertERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
            <return type-id='type-id-821'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::insert(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6insertESt17_Rb_tree_iteratorIS9_ERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseESt17_Rb_tree_iteratorIS9_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseESt17_Rb_tree_iteratorIS9_ESD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::swap(std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4swapERSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-811'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<HeapProfileTable::Bucket*> std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::less<HeapProfileTable::Bucket*> -->
            <return type-id='type-id-822'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare -->
            <return type-id='type-id-805'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::count(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5countERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-823'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-824'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
      <class-decl name='set&lt;MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='88' column='1' id='type-id-189'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-825' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='112' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set() -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set(const MemoryRegionMap::RegionCmp&, const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
            <parameter type-id='type-id-827'/>
            <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
            <parameter type-id='type-id-828'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set(const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-829'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::operator=(const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEEaSERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-829'/>
            <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
            <return type-id='type-id-830'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='274' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='282' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
            <return type-id='type-id-832'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='300' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='361' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='371' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::swap(std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4swapERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='389' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-830'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::insert(const MemoryRegionMap::Region&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6insertERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='408' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> -->
            <return type-id='type-id-834'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::insert(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6insertESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='435' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='475' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region&) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='490' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_ES8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='505' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='515' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::count(const MemoryRegionMap::Region&) -->
          <function-decl name='count' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5countERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='547' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='551' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='568' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='588' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='609' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- const HeapProfileTable::Snapshot::Entry& -->
    <reference-type-def kind='lvalue' type-id='type-id-836' size-in-bits='64' id='type-id-224'/>
    <!-- const HeapProfileTable::Snapshot::Entry* -->
    <pointer-type-def type-id='type-id-836' size-in-bits='64' id='type-id-223'/>
    <!-- const MemoryRegionMap::RegionCmp* -->
    <pointer-type-def type-id='type-id-837' size-in-bits='64' id='type-id-182'/>
    <!-- const bool -->
    <qualified-type-def type-id='type-id-55' const='yes' id='type-id-477'/>
    <!-- const char& -->
    <reference-type-def kind='lvalue' type-id='type-id-58' size-in-bits='64' id='type-id-303'/>
    <!-- const ptrdiff_t& -->
    <reference-type-def kind='lvalue' type-id='type-id-838' size-in-bits='64' id='type-id-797'/>
    <!-- const std::_Rb_tree_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-520' size-in-bits='64' id='type-id-743'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-839' size-in-bits='64' id='type-id-795'/>
    <!-- const uintptr_t -->
    <qualified-type-def type-id='type-id-145' const='yes' id='type-id-282'/>
    <!-- const unsigned long int -->
    <qualified-type-def type-id='type-id-5' const='yes' id='type-id-633'/>
    <!-- const unsigned long int& -->
    <reference-type-def kind='lvalue' type-id='type-id-633' size-in-bits='64' id='type-id-352'/>
    <!-- size_t (const HeapProfileTable::AllocValue&) -->
    <function-type size-in-bits='64' id='type-id-714'>
      <!-- parameter of type 'const HeapProfileTable::AllocValue&' -->
      <parameter type-id='type-id-233'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-type>
    <!-- void (const HeapProfileTable::AllocContextInfo&) -->
    <function-type size-in-bits='64' id='type-id-722'>
      <!-- parameter of type 'const HeapProfileTable::AllocContextInfo&' -->
      <parameter type-id='type-id-436'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, void (void*, const HeapProfileTable::AllocInfo&)*) -->
    <function-type size-in-bits='64' id='type-id-723'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'void (void*, const HeapProfileTable::AllocInfo&)*' -->
      <parameter type-id='type-id-243'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, const HeapProfileTable::AllocInfo&) -->
    <function-type size-in-bits='64' id='type-id-724'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'const HeapProfileTable::AllocInfo&' -->
      <parameter type-id='type-id-438'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, ptrdiff_t) -->
    <function-type size-in-bits='64' id='type-id-725'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef ptrdiff_t' -->
      <parameter type-id='type-id-208'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, void*, size_t, int, int, int, off_t) -->
    <function-type size-in-bits='64' id='type-id-727'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'typedef off_t' -->
      <parameter type-id='type-id-207'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void* (size_t) -->
    <function-type size-in-bits='64' id='type-id-729'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-type>
    <!-- size_t* -->
    <pointer-type-def type-id='type-id-57' size-in-bits='64' id='type-id-252'/>
    <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-519' size-in-bits='64' id='type-id-745'/>
    <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-519' size-in-bits='64' id='type-id-741'/>
    <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-538' size-in-bits='64' id='type-id-742'/>
    <namespace-decl name='std'>
      <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
      <class-decl name='basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='52' column='1' id='type-id-796'>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep -->
          <class-decl name='_Rep' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='148' column='1' id='type-id-580'>
            <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-840'/>
            <data-member access='public' static='yes'>
              <!-- static const size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_max_size -->
              <var-decl name='_S_max_size' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='51' column='1'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static const char std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_terminal -->
              <var-decl name='_S_terminal' type-id='type-id-58' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='56' column='1'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_empty_rep_storage[4] -->
              <var-decl name='_S_empty_rep_storage' type-id='type-id-150' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='68' column='1'/>
            </data-member>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_empty_rep() -->
              <function-decl name='_S_empty_rep' mangled-name='_ZNSs4_Rep12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
                <return type-id='type-id-841'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_is_leaked() -->
              <function-decl name='_M_is_leaked' mangled-name='_ZNKSs4_Rep12_M_is_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-582' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_is_shared() -->
              <function-decl name='_M_is_shared' mangled-name='_ZNKSs4_Rep12_M_is_sharedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='187' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-582' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_leaked() -->
              <function-decl name='_M_set_leaked' mangled-name='_ZNSs4_Rep13_M_set_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='191' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_sharable() -->
              <function-decl name='_M_set_sharable' mangled-name='_ZNSs4_Rep15_M_set_sharableEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_length_and_sharable(unsigned long int) -->
              <function-decl name='_M_set_length_and_sharable' mangled-name='_ZNSs4_Rep26_M_set_length_and_sharableEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_refdata() -->
              <function-decl name='_M_refdata' mangled-name='_ZNSs4_Rep10_M_refdataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_grab(const std::allocator<char>&, const std::allocator<char>&) -->
              <function-decl name='_M_grab' mangled-name='_ZNSs4_Rep7_M_grabERKSaIcES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='218' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_create(unsigned long int, const std::allocator<char>&) -->
              <function-decl name='_S_create' mangled-name='_ZNSs4_Rep9_S_createEmmRKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='546' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
                <return type-id='type-id-842'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_dispose(const std::allocator<char>&) -->
              <function-decl name='_M_dispose' mangled-name='_ZNSs4_Rep10_M_disposeERKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_destroy(const std::allocator<char>&) -->
              <function-decl name='_M_destroy' mangled-name='_ZNSs4_Rep10_M_destroyERKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='445' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_refcopy() -->
              <function-decl name='_M_refcopy' mangled-name='_ZNSs4_Rep10_M_refcopyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_clone(const std::allocator<char>&, unsigned long int) -->
              <function-decl name='_M_clone' mangled-name='_ZNSs4_Rep8_M_cloneERKSaIcEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='624' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider -->
          <class-decl name='_Alloc_hider' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='258' column='1' id='type-id-844'>
            <!-- class std::allocator<char> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-845'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider::_M_p -->
              <var-decl name='_M_p' type-id='type-id-113' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='262' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider::_Alloc_hider(char*, const std::allocator<char>&) -->
              <function-decl name='_Alloc_hider' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider*' -->
                <parameter type-id='type-id-846' is-artificial='yes'/>
                <!-- parameter of type 'char*' -->
                <parameter type-id='type-id-113'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base -->
          <class-decl name='_Rep_base' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='141' column='1' id='type-id-840'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_length -->
              <var-decl name='_M_length' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='142' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_capacity -->
              <var-decl name='_M_capacity' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='143' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- _Atomic_word std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_refcount -->
              <var-decl name='_M_refcount' type-id='type-id-370' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='144' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <data-member access='public' static='yes'>
          <!-- static const size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::npos -->
          <var-decl name='npos' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='270' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_dataplus -->
          <var-decl name='_M_dataplus' type-id='type-id-844' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='274' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_data() -->
          <function-decl name='_M_data' mangled-name='_ZNKSs7_M_dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_data(char*) -->
          <function-decl name='_M_data' mangled-name='_ZNSs7_M_dataEPc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_rep() -->
          <function-decl name='_M_rep' mangled-name='_ZNKSs6_M_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='285' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
            <return type-id='type-id-842'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_ibegin() -->
          <function-decl name='_M_ibegin' mangled-name='_ZNKSs9_M_ibeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_iend() -->
          <function-decl name='_M_iend' mangled-name='_ZNKSs7_M_iendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_leak() -->
          <function-decl name='_M_leak' mangled-name='_ZNSs7_M_leakEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_check(unsigned long int, const char*) -->
          <function-decl name='_M_check' mangled-name='_ZNKSs8_M_checkEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_check_length(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='_M_check_length' mangled-name='_ZNKSs15_M_check_lengthEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='314' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_limit(unsigned long int, unsigned long int) -->
          <function-decl name='_M_limit' mangled-name='_ZNKSs8_M_limitEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='322' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_disjunct(const char*) -->
          <function-decl name='_M_disjunct' mangled-name='_ZNKSs11_M_disjunctEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_copy(const char*, unsigned long int) -->
          <function-decl name='_M_copy' mangled-name='_ZNSs7_M_copyEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='339' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_move(const char*, unsigned long int) -->
          <function-decl name='_M_move' mangled-name='_ZNSs7_M_moveEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='348' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_assign(unsigned long int, char) -->
          <function-decl name='_M_assign' mangled-name='_ZNSs9_M_assignEPcmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='357' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIS_SsEES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIPKcSsEES4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='380' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(char*, char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcS_S_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(const char*, const char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcPKcS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='388' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_compare(unsigned long int) -->
          <function-decl name='_S_compare' mangled-name='_ZNSs10_S_compareEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='392' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate(unsigned long int, unsigned long int, unsigned long int) -->
          <function-decl name='_M_mutate' mangled-name='_ZNSs9_M_mutateEmmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_leak_hard() -->
          <function-decl name='_M_leak_hard' mangled-name='_ZNSs12_M_leak_hardEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_empty_rep() -->
          <function-decl name='_S_empty_rep' mangled-name='_ZNSs12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='411' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
            <return type-id='type-id-841'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string() -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2144' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='194' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const char*, unsigned long int, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const char*, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='213' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(unsigned long int, char, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='220' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string(int) -->
          <function-decl name='~basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='502' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='510' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const char*) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(char) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSs5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='554' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSs5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-850'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::end() -->
          <function-decl name='end' mangled-name='_ZNSs3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='573' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSs3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-850'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSs6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-852'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSs6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='602' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-853'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSs4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='611' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-852'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSs4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='620' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-853'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSs4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::length() -->
          <function-decl name='length' mangled-name='_ZNKSs6lengthEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSs8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::resize(unsigned long int, char) -->
          <function-decl name='resize' mangled-name='_ZNSs6resizeEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='640' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::resize(unsigned long int) -->
          <function-decl name='resize' mangled-name='_ZNSs6resizeEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSs8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSs7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='502' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSs5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSs5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='708' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSsixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSsixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='740' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSs2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='761' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSs2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='780' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='795' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(const char*) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='804' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(char) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='813' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='append' mangled-name='_ZNSs6appendERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='325' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSs6appendERKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const char*, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='298' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const char*) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='868' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(unsigned long int, char) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::push_back(char) -->
          <function-decl name='push_back' mangled-name='_ZNSs9push_backEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='914' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignERKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='944' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const char*, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const char*) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='972' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(unsigned long int, char) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='988' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEN9__gnu_cxx17__normal_iteratorIPcSsEEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1028' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1071' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1093' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const char*, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const char*) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1157' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEN9__gnu_cxx17__normal_iteratorIPcSsEEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(unsigned long int, unsigned long int) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1198' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEN9__gnu_cxx17__normal_iteratorIPcSsEE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1214' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEN9__gnu_cxx17__normal_iteratorIPcSsEES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='391' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1275' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_RKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1359' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1377' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1398' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_mc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1419' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, char*, char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_S1_S1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKcS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_S2_S2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1476' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_NS0_IPKcSsEES5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1486' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_replace_aux(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='_M_replace_aux' mangled-name='_ZNSs14_M_replace_auxEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_replace_safe(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='_M_replace_safe' mangled-name='_ZNSs15_M_replace_safeEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='681' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_construct(char, const std::allocator<char>&) -->
          <function-decl name='_S_construct' mangled-name='_ZNSs12_S_constructEmcRKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::copy(char*, unsigned long int, unsigned long int) -->
          <function-decl name='copy' mangled-name='_ZNKSs4copyEPcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='swap' mangled-name='_ZNSs4swapERSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='519' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-851'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::c_str() -->
          <function-decl name='c_str' mangled-name='_ZNKSs5c_strEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1612' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSs4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1622' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::allocator<char> std::basic_string<char, std::char_traits<char>, std::allocator<char> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSs13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1629' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::allocator<char> -->
            <return type-id='type-id-845'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='737' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1657' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const char*, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1671' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(char, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='760' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='778' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const char*, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1729' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(char, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1759' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='816' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const char*, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1787' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(char, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1806' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1820' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='831' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const char*, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1848' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(char, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1867' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1881' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const char*, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1910' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(char, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='864' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1940' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='875' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const char*, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1969' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(char, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='896' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::substr(unsigned long int, unsigned long int) -->
          <function-decl name='substr' mangled-name='_ZNKSs6substrEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2001' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
            <return type-id='type-id-796'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2019' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='916' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='931' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='949' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='964' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='980' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- typedef intptr_t AtomicWord -->
    <typedef-decl name='AtomicWord' type-id='type-id-77' filepath='./src/base/atomicops.h' line='129' column='1' id='type-id-798'/>
    <!-- typedef long int __off_t -->
    <typedef-decl name='__off_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='141' column='1' id='type-id-305'/>
    <!-- typedef unsigned long int pthread_t -->
    <typedef-decl name='pthread_t' type-id='type-id-5' filepath='/usr/include/bits/pthreadtypes.h' line='50' column='1' id='type-id-199'/>
    <!-- typedef long int ptrdiff_t -->
    <typedef-decl name='ptrdiff_t' type-id='type-id-80' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/include/stddef.h' line='149' column='1' id='type-id-208'/>
    <!-- typedef __ssize_t ssize_t -->
    <typedef-decl name='ssize_t' type-id='type-id-854' filepath='/usr/include/stdio.h' line='103' column='1' id='type-id-274'/>
    <namespace-decl name='std'>
      <!-- typedef std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::string -->
      <typedef-decl name='string' type-id='type-id-796' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='56' column='1' id='type-id-800'/>
    </namespace-decl>
    <!-- void ()* -->
    <pointer-type-def type-id='type-id-855' size-in-bits='64' id='type-id-176'/>
    <!-- void (const HeapProfileBucket*, HeapProfileTable::BufferArgs*)* -->
    <pointer-type-def type-id='type-id-856' size-in-bits='64' id='type-id-203'/>
    <!-- void (const MemoryRegionMap::Region&)* -->
    <pointer-type-def type-id='type-id-857' size-in-bits='64' id='type-id-206'/>
    <!-- void (void*)* -->
    <pointer-type-def type-id='type-id-858' size-in-bits='64' id='type-id-240'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*)* -->
    <pointer-type-def type-id='type-id-859' size-in-bits='64' id='type-id-294'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*)* -->
    <pointer-type-def type-id='type-id-860' size-in-bits='64' id='type-id-295'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*)* -->
    <pointer-type-def type-id='type-id-861' size-in-bits='64' id='type-id-297'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, char*)* -->
    <pointer-type-def type-id='type-id-862' size-in-bits='64' id='type-id-293'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&)* -->
    <pointer-type-def type-id='type-id-863' size-in-bits='64' id='type-id-296'/>
    <!-- void (void*, typedef size_t)* -->
    <pointer-type-def type-id='type-id-864' size-in-bits='64' id='type-id-381'/>
    <!-- void* (unsigned long int)* -->
    <pointer-type-def type-id='type-id-865' size-in-bits='64' id='type-id-286'/>
    <!-- void*[20][32] -->
    <array-type-def dimensions='2' type-id='type-id-53' size-in-bits='40960' id='type-id-202'>
      <!-- <anonymous range>[20] -->
      <subrange length='20' type-id='type-id-5' id='type-id-802'/>
      <!-- <anonymous range>[32] -->
      <subrange length='32' type-id='type-id-5' id='type-id-153'/>
    </array-type-def>
    <!-- HeapProfileTable::AllocValue::Bucket* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-866' size-in-bits='64' id='type-id-818'/>
    <!-- HeapProfileTable::Snapshot::Entry& -->
    <reference-type-def kind='lvalue' type-id='type-id-221' size-in-bits='64' id='type-id-819'/>
    <!-- class MallocExtension -->
    <class-decl name='MallocExtension' size-in-bits='64' visibility='default' filepath='src/gperftools/malloc_extension.h' line='90' column='1' id='type-id-803'>
      <member-type access='private'>
        <!-- enum MallocExtension::Ownership -->
        <enum-decl name='Ownership' filepath='./src/gperftools/malloc_extension.h' line='315' column='1' id='type-id-867'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kUnknownOwnership' value='0'/>
          <enumerator name='kOwned' value='1'/>
          <enumerator name='kNotOwned' value='2'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct MallocExtension::FreeListInfo -->
        <class-decl name='FreeListInfo' size-in-bits='256' is-struct='yes' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='333' column='1' id='type-id-868'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- size_t MallocExtension::FreeListInfo::min_object_size -->
            <var-decl name='min_object_size' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='334' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- size_t MallocExtension::FreeListInfo::max_object_size -->
            <var-decl name='max_object_size' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='335' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- size_t MallocExtension::FreeListInfo::total_bytes_free -->
            <var-decl name='total_bytes_free' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='336' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='192'>
            <!-- const char* MallocExtension::FreeListInfo::type -->
            <var-decl name='type' type-id='type-id-52' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='337' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef void (void*, const base::MallocRange*) MallocExtension::RangeFunction -->
        <typedef-decl name='RangeFunction' type-id='type-id-870' filepath='src/gperftools/malloc_extension.h' line='143' column='1' id='type-id-869'/>
      </member-type>
      <member-function access='private' static='yes'>
        <!-- void MallocExtension::Initialize() -->
        <function-decl name='Initialize' mangled-name='_ZN15MallocExtension10InitializeEv' filepath='src/malloc_extension.cc' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension10InitializeEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocExtension* MallocExtension::instance() -->
        <function-decl name='instance' mangled-name='_ZN15MallocExtension8instanceEv' filepath='src/malloc_extension.cc' line='212' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8instanceEv'>
          <!-- MallocExtension* -->
          <return type-id='type-id-278'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void MallocExtension::Register() -->
        <function-decl name='Register' mangled-name='_ZN15MallocExtension8RegisterEPS_' filepath='src/malloc_extension.cc' line='217' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8RegisterEPS_'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes' vtable-offset='-1'>
        <!-- MallocExtension::~MallocExtension(int) -->
        <function-decl name='~MallocExtension' mangled-name='_ZN15MallocExtensionD1Ev' filepath='src/malloc_extension.cc' line='111' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtensionD1Ev'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- bool MallocExtension::VerifyAllMemory() -->
        <function-decl name='VerifyAllMemory' mangled-name='_ZN15MallocExtension15VerifyAllMemoryEv' filepath='src/malloc_extension.cc' line='112' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15VerifyAllMemoryEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='3'>
        <!-- bool MallocExtension::VerifyNewMemory(void*) -->
        <function-decl name='VerifyNewMemory' mangled-name='_ZN15MallocExtension15VerifyNewMemoryEPKv' filepath='src/malloc_extension.cc' line='113' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15VerifyNewMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='4'>
        <!-- bool MallocExtension::VerifyArrayNewMemory(void*) -->
        <function-decl name='VerifyArrayNewMemory' mangled-name='_ZN15MallocExtension20VerifyArrayNewMemoryEPKv' filepath='src/malloc_extension.cc' line='114' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20VerifyArrayNewMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='5'>
        <!-- bool MallocExtension::VerifyMallocMemory(void*) -->
        <function-decl name='VerifyMallocMemory' mangled-name='_ZN15MallocExtension18VerifyMallocMemoryEPKv' filepath='src/malloc_extension.cc' line='115' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18VerifyMallocMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='6'>
        <!-- bool MallocExtension::MallocMemoryStats(int*, size_t*, int*) -->
        <function-decl name='MallocMemoryStats' mangled-name='_ZN15MallocExtension17MallocMemoryStatsEPiPmS0_' filepath='src/malloc_extension.cc' line='130' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension17MallocMemoryStatsEPiPmS0_'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='7'>
        <!-- void MallocExtension::GetStats(char*, int) -->
        <function-decl name='GetStats' mangled-name='_ZN15MallocExtension8GetStatsEPci' filepath='src/malloc_extension.cc' line='125' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8GetStatsEPci'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='8'>
        <!-- void MallocExtension::GetHeapSample(MallocExtensionWriter*) -->
        <function-decl name='GetHeapSample' mangled-name='_ZN15MallocExtension13GetHeapSampleEPSs' filepath='src/malloc_extension.cc' line='292' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension13GetHeapSampleEPSs'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'MallocExtensionWriter*' -->
          <parameter type-id='type-id-872'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='9'>
        <!-- void MallocExtension::GetHeapGrowthStacks(MallocExtensionWriter*) -->
        <function-decl name='GetHeapGrowthStacks' mangled-name='_ZN15MallocExtension19GetHeapGrowthStacksEPSs' filepath='src/malloc_extension.cc' line='316' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension19GetHeapGrowthStacksEPSs'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'MallocExtensionWriter*' -->
          <parameter type-id='type-id-872'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='10'>
        <!-- void MallocExtension::Ranges(void*, MallocExtension::RangeFunction*) -->
        <function-decl name='Ranges' mangled-name='_ZN15MallocExtension6RangesEPvPFvS0_PKN4base11MallocRangeEE' filepath='src/malloc_extension.cc' line='340' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension6RangesEPvPFvS0_PKN4base11MallocRangeEE'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'MallocExtension::RangeFunction*' -->
          <parameter type-id='type-id-873'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='11'>
        <!-- bool MallocExtension::GetNumericProperty(const char*, size_t*) -->
        <function-decl name='GetNumericProperty' mangled-name='_ZN15MallocExtension18GetNumericPropertyEPKcPm' filepath='src/malloc_extension.cc' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18GetNumericPropertyEPKcPm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='12'>
        <!-- bool MallocExtension::SetNumericProperty(const char*, size_t) -->
        <function-decl name='SetNumericProperty' mangled-name='_ZN15MallocExtension18SetNumericPropertyEPKcm' filepath='src/malloc_extension.cc' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18SetNumericPropertyEPKcm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='13'>
        <!-- void MallocExtension::MarkThreadIdle() -->
        <function-decl name='MarkThreadIdle' mangled-name='_ZN15MallocExtension14MarkThreadIdleEv' filepath='src/malloc_extension.cc' line='146' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension14MarkThreadIdleEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='14'>
        <!-- void MallocExtension::MarkThreadBusy() -->
        <function-decl name='MarkThreadBusy' mangled-name='_ZN15MallocExtension14MarkThreadBusyEv' filepath='src/malloc_extension.cc' line='150' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension14MarkThreadBusyEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='15'>
        <!-- SysAllocator* MallocExtension::GetSystemAllocator() -->
        <function-decl name='GetSystemAllocator' mangled-name='_ZN15MallocExtension18GetSystemAllocatorEv' filepath='src/malloc_extension.cc' line='154' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18GetSystemAllocatorEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- SysAllocator* -->
          <return type-id='type-id-874'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='16'>
        <!-- void MallocExtension::SetSystemAllocator(SysAllocator*) -->
        <function-decl name='SetSystemAllocator' mangled-name='_ZN15MallocExtension18SetSystemAllocatorEP12SysAllocator' filepath='src/malloc_extension.cc' line='158' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18SetSystemAllocatorEP12SysAllocator'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='17'>
        <!-- void MallocExtension::ReleaseToSystem(size_t) -->
        <function-decl name='ReleaseToSystem' mangled-name='_ZN15MallocExtension15ReleaseToSystemEm' filepath='src/malloc_extension.cc' line='162' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15ReleaseToSystemEm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='18'>
        <!-- void MallocExtension::ReleaseFreeMemory() -->
        <function-decl name='ReleaseFreeMemory' mangled-name='_ZN15MallocExtension17ReleaseFreeMemoryEv' filepath='src/malloc_extension.cc' line='166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension17ReleaseFreeMemoryEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='19'>
        <!-- void MallocExtension::SetMemoryReleaseRate(double) -->
        <function-decl name='SetMemoryReleaseRate' mangled-name='_ZN15MallocExtension20SetMemoryReleaseRateEd' filepath='src/malloc_extension.cc' line='170' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20SetMemoryReleaseRateEd'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'double' -->
          <parameter type-id='type-id-2'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='20'>
        <!-- double MallocExtension::GetMemoryReleaseRate() -->
        <function-decl name='GetMemoryReleaseRate' mangled-name='_ZN15MallocExtension20GetMemoryReleaseRateEv' filepath='src/malloc_extension.cc' line='174' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20GetMemoryReleaseRateEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- double -->
          <return type-id='type-id-2'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='21'>
        <!-- size_t MallocExtension::GetEstimatedAllocatedSize(size_t) -->
        <function-decl name='GetEstimatedAllocatedSize' mangled-name='_ZN15MallocExtension25GetEstimatedAllocatedSizeEm' filepath='src/malloc_extension.cc' line='178' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension25GetEstimatedAllocatedSizeEm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='22'>
        <!-- size_t MallocExtension::GetAllocatedSize(void*) -->
        <function-decl name='GetAllocatedSize' mangled-name='_ZN15MallocExtension16GetAllocatedSizeEPKv' filepath='src/malloc_extension.cc' line='182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension16GetAllocatedSizeEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='23'>
        <!-- MallocExtension::Ownership MallocExtension::GetOwnership(void*) -->
        <function-decl name='GetOwnership' mangled-name='_ZN15MallocExtension12GetOwnershipEPKv' filepath='src/malloc_extension.cc' line='187' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension12GetOwnershipEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- enum MallocExtension::Ownership -->
          <return type-id='type-id-867'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='24'>
        <!-- void MallocExtension::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*) -->
        <function-decl name='GetFreeListSizes' mangled-name='_ZN15MallocExtension16GetFreeListSizesEPSt6vectorINS_12FreeListInfoESaIS1_EE' filepath='src/malloc_extension.cc' line='191' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension16GetFreeListSizesEPSt6vectorINS_12FreeListInfoESaIS1_EE'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
          <parameter type-id='type-id-875'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='25'>
        <!-- void** MallocExtension::ReadStackTraces(int*) -->
        <function-decl name='ReadStackTraces' mangled-name='_ZN15MallocExtension15ReadStackTracesEPi' filepath='src/malloc_extension.cc' line='138' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15ReadStackTracesEPi'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='26'>
        <!-- void** MallocExtension::ReadHeapGrowthStackTraces() -->
        <function-decl name='ReadHeapGrowthStackTraces' mangled-name='_ZN15MallocExtension25ReadHeapGrowthStackTracesEv' filepath='src/malloc_extension.cc' line='142' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension25ReadHeapGrowthStackTracesEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
    <class-decl name='STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-832'>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator(const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-828'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::address(MemoryRegionMap::Region&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7addressERS1_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-744'/>
          <!-- MemoryRegionMap::Region* -->
          <return type-id='type-id-186'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::address(const MemoryRegionMap::Region&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7addressERKS1_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- const MemoryRegionMap::Region* -->
          <return type-id='type-id-185'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- MemoryRegionMap::Region* -->
          <return type-id='type-id-186'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::deallocate(MemoryRegionMap::Region*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE10deallocateEPS1_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::construct(MemoryRegionMap::Region*, const MemoryRegionMap::Region&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE9constructEPS1_RKS1_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::construct(MemoryRegionMap::Region*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE9constructEPS1_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::destroy(MemoryRegionMap::Region*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7destroyEPS1_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::operator==(const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEEeqERKS3_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-828'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region> >(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;MemoryRegionMap::Region&gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
      <class-decl name='__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-849'/>
    </namespace-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
      <class-decl name='__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-850'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='_Rb_tree&lt;HeapProfileTable::Bucket*, std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt;, std::_Select1st&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::less&lt;HeapProfileTable::Bucket*&gt;, std::allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-806'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;HeapProfileTable::Bucket*&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-879'>
            <!-- class std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-880'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<HeapProfileTable::Bucket*> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-822' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_Rb_tree_impl(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
                <parameter type-id='type-id-808'/>
                <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
                <parameter type-id='type-id-882'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13_Rb_tree_implISB_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-879' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-884'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-882'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-813'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_put_node(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_put_nodeEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_create_node(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_create_nodeERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_destroy_node(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_clone_node(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_valueEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_S_keyEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_M_insert_EPKSt18_Rb_tree_node_baseSG_RKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_M_insert_EPKSt18_Rb_tree_node_baseSG_RKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_insert_lowerEPSt18_Rb_tree_node_baseSF_RKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal_lower(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_insert_equal_lowerERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_copy(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_copyEPKSt13_Rb_tree_nodeIS7_EPSF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_erase(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_eraseEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_eraseEPSt13_Rb_tree_nodeIS7_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_lower_bound(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_lower_boundEPSt13_Rb_tree_nodeIS7_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_lower_bound(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_lower_boundEPKSt13_Rb_tree_nodeIS7_ESH_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_upper_bound(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_upper_boundEPSt13_Rb_tree_nodeIS7_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_upper_bound(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_upper_boundEPKSt13_Rb_tree_nodeIS7_ESH_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
            <parameter type-id='type-id-808'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree(const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-888'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator=(const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EEaSERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-888'/>
            <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-889'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<HeapProfileTable::Bucket*> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::less<HeapProfileTable::Bucket*> -->
            <return type-id='type-id-822'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::swap(std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4swapERSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-889'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_uniqueERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_uniqueERKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
            <return type-id='type-id-821'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_insert_equalERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS7_ERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS7_ERKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS7_ERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt17_Rb_tree_iteratorIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt23_Rb_tree_const_iteratorIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt17_Rb_tree_iteratorIS7_ESF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt23_Rb_tree_const_iteratorIS7_ESF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const*, HeapProfileTable::AllocValue::Bucket* const*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseEPS3_SE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::count(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5countERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-823'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-824'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
      <class-decl name='_Rb_tree&lt;MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity&lt;MemoryRegionMap::Region&gt;, MemoryRegionMap::RegionCmp, STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-825'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true> -->
          <class-decl name='_Rb_tree_impl&lt;MemoryRegionMap::RegionCmp, true&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-891'>
            <!-- class STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-892'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- MemoryRegionMap::RegionCmp std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-181' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_Rb_tree_impl(const MemoryRegionMap::RegionCmp&, const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
                <parameter type-id='type-id-827'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
                <parameter type-id='type-id-878'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13_Rb_tree_implIS4_Lb1EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-891' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
            <return type-id='type-id-895'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
            <return type-id='type-id-878'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
            <return type-id='type-id-832'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_put_node(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_put_nodeEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_create_node(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_create_nodeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_destroy_node(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_clone_node(const std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_valueEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_S_keyEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKS1_'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_insert_lowerEPSt18_Rb_tree_node_baseSA_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal_lower(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_insert_equal_lowerERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_copy(const std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_copyEPKSt13_Rb_tree_nodeIS1_EPSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_erase(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS1_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_lower_bound(std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_lower_boundEPSt13_Rb_tree_nodeIS1_ESB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_lower_bound(const std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_lower_boundEPKSt13_Rb_tree_nodeIS1_ESC_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_upper_bound(std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_upper_boundEPSt13_Rb_tree_nodeIS1_ESB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_upper_bound(const std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_upper_boundEPKSt13_Rb_tree_nodeIS1_ESC_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree(const MemoryRegionMap::RegionCmp&, const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
            <parameter type-id='type-id-827'/>
            <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
            <parameter type-id='type-id-828'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree(const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-897'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::operator=(const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEEaSERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-897'/>
            <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
            <return type-id='type-id-898'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-899'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-899'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::swap(std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4swapERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-898'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_unique(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE16_M_insert_uniqueERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> -->
            <return type-id='type-id-900'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_insert_equalERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt17_Rb_tree_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt17_Rb_tree_iteratorIS1_ESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_ESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region*, const MemoryRegionMap::Region*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseEPKS1_SA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region*' -->
            <parameter type-id='type-id-185'/>
            <!-- parameter of type 'const MemoryRegionMap::Region*' -->
            <parameter type-id='type-id-185'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::count(const MemoryRegionMap::Region&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5countERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-901'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::allocator<char> -->
      <class-decl name='allocator&lt;char&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='45' column='1' id='type-id-845'>
        <!-- class __gnu_cxx::new_allocator<char> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-902'/>
        <member-function access='private'>
          <!-- void std::allocator<char>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<char>::allocator(const std::allocator<char>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<char>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-813'>
        <!-- class __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-904'/>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator(const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >(const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-882'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-852'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-853'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-833'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-817'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-816'/>
    </namespace-decl>
    <!-- const HeapProfileTable::Snapshot::Entry -->
    <qualified-type-def type-id='type-id-221' const='yes' id='type-id-836'/>
    <!-- const MemoryRegionMap::RegionCmp -->
    <qualified-type-def type-id='type-id-181' const='yes' id='type-id-837'/>
    <!-- const MemoryRegionMap::RegionCmp& -->
    <reference-type-def kind='lvalue' type-id='type-id-837' size-in-bits='64' id='type-id-827'/>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-906' size-in-bits='64' id='type-id-828'/>
    <!-- const ptrdiff_t -->
    <qualified-type-def type-id='type-id-208' const='yes' id='type-id-838'/>
    <!-- const std::allocator<char>& -->
    <reference-type-def kind='lvalue' type-id='type-id-907' size-in-bits='64' id='type-id-843'/>
    <!-- const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-908' size-in-bits='64' id='type-id-809'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
    <qualified-type-def type-id='type-id-796' const='yes' id='type-id-839'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >* -->
    <pointer-type-def type-id='type-id-839' size-in-bits='64' id='type-id-847'/>
    <!-- const std::less<HeapProfileTable::Bucket*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-909' size-in-bits='64' id='type-id-808'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-910' size-in-bits='64' id='type-id-810'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-910' size-in-bits='64' id='type-id-812'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
    <reference-type-def kind='lvalue' type-id='type-id-911' size-in-bits='64' id='type-id-820'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-912' size-in-bits='64' id='type-id-829'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-912' size-in-bits='64' id='type-id-831'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-796' size-in-bits='64' id='type-id-851'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >* -->
    <pointer-type-def type-id='type-id-796' size-in-bits='64' id='type-id-848'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider* -->
    <pointer-type-def type-id='type-id-844' size-in-bits='64' id='type-id-846'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
    <reference-type-def kind='lvalue' type-id='type-id-580' size-in-bits='64' id='type-id-841'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
    <pointer-type-def type-id='type-id-580' size-in-bits='64' id='type-id-842'/>
    <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-226' size-in-bits='64' id='type-id-811'/>
    <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-226' size-in-bits='64' id='type-id-807'/>
    <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-189' size-in-bits='64' id='type-id-830'/>
    <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-189' size-in-bits='64' id='type-id-826'/>
    <namespace-decl name='std'>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-815'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-916'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-917'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-917'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator==(const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEeqERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-918'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator!=(const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEneERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-918'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-814'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-921'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-923'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-923'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator==(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEeqERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator!=(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEneERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::less<HeapProfileTable::Bucket*> -->
      <class-decl name='less&lt;HeapProfileTable::Bucket*&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='227' column='1' id='type-id-822'>
        <!-- struct std::binary_function<HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-924'/>
        <member-function access='public'>
          <!-- bool std::less<HeapProfileTable::Bucket*>::operator()(HeapProfileTable::AllocValue::Bucket* const&, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt4lessIP17HeapProfileBucketEclERKS1_S4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::less<HeapProfileTable::Bucket*>*' -->
            <parameter type-id='type-id-925' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-834'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::first -->
          <var-decl name='first' type-id='type-id-198' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-926' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::pair(const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-926' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-501'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt;, std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-835'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-824'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-821'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::first -->
          <var-decl name='first' type-id='type-id-814' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>*' -->
            <parameter type-id='type-id-927' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::pair(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>*' -->
            <parameter type-id='type-id-927' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-823'/>
    </namespace-decl>
    <!-- typedef long int __ssize_t -->
    <typedef-decl name='__ssize_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='180' column='1' id='type-id-854'/>
    <!-- HeapProfileTable::AllocValue::Bucket* const -->
    <qualified-type-def type-id='type-id-214' const='yes' id='type-id-866'/>
    <!-- HeapProfileTable::AllocValue::Bucket* const* -->
    <pointer-type-def type-id='type-id-866' size-in-bits='64' id='type-id-890'/>
    <!-- MallocExtension::RangeFunction* -->
    <pointer-type-def type-id='type-id-869' size-in-bits='64' id='type-id-873'/>
    <!-- MallocExtensionWriter* -->
    <pointer-type-def type-id='type-id-928' size-in-bits='64' id='type-id-872'/>
    <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-832' size-in-bits='64' id='type-id-876'/>
    <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-892' size-in-bits='64' id='type-id-895'/>
    <!-- SysAllocator* -->
    <pointer-type-def type-id='type-id-929' size-in-bits='64' id='type-id-874'/>
    <!-- class STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;MemoryRegionMap::Region&gt;, MemoryRegionMap::MyAllocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-892'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::address(std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7addressERS3_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-932'/>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-742'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::address(const std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7addressERKS3_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-933'/>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-540'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-742'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::deallocate(std::_Rb_tree_node<MemoryRegionMap::Region>*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE10deallocateEPS3_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::construct(std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE9constructEPS3_RKS3_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-933'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::construct(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE9constructEPS3_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::destroy(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7destroyEPS3_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::operator==(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEEeqERKS5_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<char> -->
      <class-decl name='new_allocator&lt;char&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-902'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::new_allocator(const __gnu_cxx::new_allocator<char>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<char>&' -->
            <parameter type-id='type-id-935'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<char>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* __gnu_cxx::new_allocator<char>::address(char&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE7addressERc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- parameter of type 'char&' -->
            <parameter type-id='type-id-302'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* __gnu_cxx::new_allocator<char>::address(const char&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE7addressERKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- parameter of type 'const char&' -->
            <parameter type-id='type-id-303'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* __gnu_cxx::new_allocator<char>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::deallocate(char*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE10deallocateEPcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<char>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::construct(char*, const char&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE9constructEPcRKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char&' -->
            <parameter type-id='type-id-303'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::destroy(char*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE7destroyEPc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='new_allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-904'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::new_allocator(const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-938'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::address(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7addressERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-921'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::address(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7addressERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-916'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::deallocate(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE10deallocateEPS8_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::construct(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE9constructEPS8_RKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::destroy(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7destroyEPS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-880'>
        <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-940'/>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocator(const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-882'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-899'/>
    </namespace-decl>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
    <qualified-type-def type-id='type-id-832' const='yes' id='type-id-906'/>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-906' size-in-bits='64' id='type-id-877'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-942' size-in-bits='64' id='type-id-878'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-943' size-in-bits='64' id='type-id-888'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-943' size-in-bits='64' id='type-id-885'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-944' size-in-bits='64' id='type-id-897'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-944' size-in-bits='64' id='type-id-896'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-945' size-in-bits='64' id='type-id-918'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-945' size-in-bits='64' id='type-id-915'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-946' size-in-bits='64' id='type-id-914'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-946' size-in-bits='64' id='type-id-920'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-947' size-in-bits='64' id='type-id-887'/>
    <!-- const std::allocator<char> -->
    <qualified-type-def type-id='type-id-845' const='yes' id='type-id-907'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-948' size-in-bits='64' id='type-id-882'/>
    <!-- const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-813' const='yes' id='type-id-908'/>
    <!-- const std::less<HeapProfileTable::Bucket*> -->
    <qualified-type-def type-id='type-id-822' const='yes' id='type-id-909'/>
    <!-- const std::less<HeapProfileTable::Bucket*>* -->
    <pointer-type-def type-id='type-id-909' size-in-bits='64' id='type-id-925'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-226' const='yes' id='type-id-910'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> -->
    <qualified-type-def type-id='type-id-949' const='yes' id='type-id-911'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
    <pointer-type-def type-id='type-id-911' size-in-bits='64' id='type-id-916'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
    <qualified-type-def type-id='type-id-189' const='yes' id='type-id-912'/>
    <!-- int* -->
    <pointer-type-def type-id='type-id-1' size-in-bits='64' id='type-id-871'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-806' size-in-bits='64' id='type-id-889'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-806' size-in-bits='64' id='type-id-883'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>* -->
    <pointer-type-def type-id='type-id-879' size-in-bits='64' id='type-id-881'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-825' size-in-bits='64' id='type-id-898'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-825' size-in-bits='64' id='type-id-894'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>* -->
    <pointer-type-def type-id='type-id-891' size-in-bits='64' id='type-id-893'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-815' size-in-bits='64' id='type-id-917'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-815' size-in-bits='64' id='type-id-913'/>
    <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-814' size-in-bits='64' id='type-id-923'/>
    <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-814' size-in-bits='64' id='type-id-919'/>
    <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-950' size-in-bits='64' id='type-id-886'/>
    <!-- std::allocator<char>* -->
    <pointer-type-def type-id='type-id-845' size-in-bits='64' id='type-id-903'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-880' size-in-bits='64' id='type-id-884'/>
    <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-813' size-in-bits='64' id='type-id-905'/>
    <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
    <reference-type-def kind='lvalue' type-id='type-id-949' size-in-bits='64' id='type-id-921'/>
    <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
    <pointer-type-def type-id='type-id-949' size-in-bits='64' id='type-id-922'/>
    <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>* -->
    <pointer-type-def type-id='type-id-834' size-in-bits='64' id='type-id-926'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>* -->
    <pointer-type-def type-id='type-id-821' size-in-bits='64' id='type-id-927'/>
    <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-951' size-in-bits='64' id='type-id-875'/>
    <namespace-decl name='std'>
      <!-- struct std::binary_function<HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool> -->
      <class-decl name='binary_function&lt;HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='113' column='1' id='type-id-924'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-900'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::first -->
          <var-decl name='first' type-id='type-id-519' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-952' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::pair(const std::_Rb_tree_iterator<MemoryRegionMap::Region>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-952' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-521'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt;, std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-901'/>
    </namespace-decl>
    <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-892' size-in-bits='64' id='type-id-930'/>
    <!-- __gnu_cxx::new_allocator<char>* -->
    <pointer-type-def type-id='type-id-902' size-in-bits='64' id='type-id-934'/>
    <!-- __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-904' size-in-bits='64' id='type-id-937'/>
    <!-- class SysAllocator -->
    <class-decl name='SysAllocator' size-in-bits='64' visibility='default' filepath='src/gperftools/malloc_extension.h' line='75' column='1' id='type-id-929'>
      <member-function access='private' constructor='yes'>
        <!-- SysAllocator::SysAllocator() -->
        <function-decl name='SysAllocator' filepath='./src/gperftools/malloc_extension.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes' vtable-offset='-1'>
        <!-- SysAllocator::~SysAllocator(int) -->
        <function-decl name='~SysAllocator' mangled-name='_ZN12SysAllocatorD1Ev' filepath='src/malloc_extension.cc' line='108' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN12SysAllocatorD1Ev'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* SysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN12SysAllocator5AllocEmPmm' filepath='src/gperftools/malloc_extension.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='new_allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-940'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::new_allocator(const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-954'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::address(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7addressERSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-956'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::address(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7addressERKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-957'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::deallocate(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE10deallocateEPSA_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::construct(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE9constructEPSA_RKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-957'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::destroy(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7destroyEPSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
      <class-decl name='vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt;' size-in-bits='192' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='171' column='1' id='type-id-951'>
        <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-958'/>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector() -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(unsigned long int, const MallocExtension::FreeListInfo&, const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-961'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::~vector(int) -->
          <function-decl name='~vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator=(const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEaSERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-961'/>
            <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
            <return type-id='type-id-962'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::assign(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='assign' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='434' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-965'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-965'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-966'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-967'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='479' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-966'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-967'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='537' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::resize(unsigned long int, MallocExtension::FreeListInfo) -->
          <function-decl name='resize' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6resizeEmS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='552' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'struct MallocExtension::FreeListInfo' -->
            <parameter type-id='type-id-868'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='574' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_range_check(unsigned long int) -->
          <function-decl name='_M_range_check' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_range_checkEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='679' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='703' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::data() -->
          <function-decl name='data' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='714' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo* std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo* -->
            <return type-id='type-id-970'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::push_back(const MallocExtension::FreeListInfo&) -->
          <function-decl name='push_back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE9push_backERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='733' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, const MallocExtension::FreeListInfo&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::erase(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::erase(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EES7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::swap(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4swapERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-962'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='950' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_initialize(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE18_M_fill_initializeEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1033' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_assign(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_fill_assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_insert_aux(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_insert_aux' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_check_len(unsigned long int, const char*) -->
          <function-decl name='_M_check_len' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE12_M_check_lenEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_erase_at_end(MallocExtension::FreeListInfo*) -->
          <function-decl name='_M_erase_at_end' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE15_M_erase_at_endEPS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
    <qualified-type-def type-id='type-id-892' const='yes' id='type-id-942'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-942' size-in-bits='64' id='type-id-931'/>
    <!-- const __gnu_cxx::new_allocator<char>& -->
    <reference-type-def kind='lvalue' type-id='type-id-971' size-in-bits='64' id='type-id-935'/>
    <!-- const __gnu_cxx::new_allocator<char>* -->
    <pointer-type-def type-id='type-id-971' size-in-bits='64' id='type-id-936'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-972' size-in-bits='64' id='type-id-938'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-972' size-in-bits='64' id='type-id-939'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-806' const='yes' id='type-id-943'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
    <qualified-type-def type-id='type-id-825' const='yes' id='type-id-944'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-815' const='yes' id='type-id-945'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-814' const='yes' id='type-id-946'/>
    <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-539' size-in-bits='64' id='type-id-933'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-950' const='yes' id='type-id-947'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-880' const='yes' id='type-id-948'/>
    <!-- std::_Rb_tree_node<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-538' size-in-bits='64' id='type-id-932'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-880' size-in-bits='64' id='type-id-941'/>
    <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>* -->
    <pointer-type-def type-id='type-id-900' size-in-bits='64' id='type-id-952'/>
    <namespace-decl name='std'>
      <!-- struct std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-950'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- struct std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> -->
      <class-decl name='pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-949'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- HeapProfileTable::AllocValue::Bucket* const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::first -->
          <var-decl name='first' type-id='type-id-866' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- HeapProfileTable::Snapshot::Entry std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::second -->
          <var-decl name='second' type-id='type-id-221' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::pair(HeapProfileTable::AllocValue::Bucket* const&, const HeapProfileTable::Snapshot::Entry&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
            <parameter type-id='type-id-224'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- typedef std::string MallocExtensionWriter -->
    <typedef-decl name='MallocExtensionWriter' type-id='type-id-800' filepath='./src/gperftools/malloc_extension.h' line='68' column='1' id='type-id-928'/>
    <!-- MallocExtension::FreeListInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-868' size-in-bits='64' id='type-id-968'/>
    <!-- MallocExtension::FreeListInfo* -->
    <pointer-type-def type-id='type-id-868' size-in-bits='64' id='type-id-969'/>
    <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-940' size-in-bits='64' id='type-id-953'/>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
      <class-decl name='__normal_iterator&lt;MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-963'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::__normal_iterator(MallocExtension::FreeListInfo* const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo* const&' -->
            <parameter type-id='type-id-974'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* const& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* const& -->
            <return type-id='type-id-974'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
      <class-decl name='__normal_iterator&lt;const MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-965'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-966'/>
    </namespace-decl>
    <namespace-decl name='std'>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-967'/>
    </namespace-decl>
    <!-- const MallocExtension::FreeListInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-977' size-in-bits='64' id='type-id-960'/>
    <!-- const MallocExtension::FreeListInfo* -->
    <pointer-type-def type-id='type-id-977' size-in-bits='64' id='type-id-970'/>
    <!-- const __gnu_cxx::new_allocator<char> -->
    <qualified-type-def type-id='type-id-902' const='yes' id='type-id-971'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-978' size-in-bits='64' id='type-id-954'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-978' size-in-bits='64' id='type-id-955'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-904' const='yes' id='type-id-972'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-947' size-in-bits='64' id='type-id-957'/>
    <!-- const std::allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-979' size-in-bits='64' id='type-id-959'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-980' size-in-bits='64' id='type-id-961'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-980' size-in-bits='64' id='type-id-964'/>
    <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-950' size-in-bits='64' id='type-id-956'/>
    <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-951' size-in-bits='64' id='type-id-962'/>
    <namespace-decl name='std'>
      <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
      <class-decl name='_Vector_base&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='70' column='1' id='type-id-958'>
        <member-type access='public'>
          <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl -->
          <class-decl name='_Vector_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='75' column='1' id='type-id-981'>
            <!-- class std::allocator<MallocExtension::FreeListInfo> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-982'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_start -->
              <var-decl name='_M_start' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='76' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_finish -->
              <var-decl name='_M_finish' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='77' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_end_of_storage -->
              <var-decl name='_M_end_of_storage' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='78' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_Vector_impl() -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl*' -->
                <parameter type-id='type-id-983' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_Vector_impl(const std::allocator<MallocExtension::FreeListInfo>&) -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl*' -->
                <parameter type-id='type-id-983' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
                <parameter type-id='type-id-959'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-981' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='136' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- std::allocator<MallocExtension::FreeListInfo>& std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- std::allocator<MallocExtension::FreeListInfo>& -->
            <return type-id='type-id-985'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::allocator<MallocExtension::FreeListInfo>& std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-986' is-artificial='yes'/>
            <!-- const std::allocator<MallocExtension::FreeListInfo>& -->
            <return type-id='type-id-959'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::allocator<MallocExtension::FreeListInfo> std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-986' is-artificial='yes'/>
            <!-- class std::allocator<MallocExtension::FreeListInfo> -->
            <return type-id='type-id-982'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base() -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base(unsigned long int, const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::~_Vector_base(int) -->
          <function-decl name='~_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_allocate(unsigned long int) -->
          <function-decl name='_M_allocate' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE11_M_allocateEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_deallocate(MallocExtension::FreeListInfo*, unsigned long int) -->
          <function-decl name='_M_deallocate' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE13_M_deallocateEPS1_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- MallocExtension::FreeListInfo* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-987' size-in-bits='64' id='type-id-974'/>
    <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-963' size-in-bits='64' id='type-id-976'/>
    <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >* -->
    <pointer-type-def type-id='type-id-963' size-in-bits='64' id='type-id-973'/>
    <namespace-decl name='std'>
      <!-- class std::allocator<MallocExtension::FreeListInfo> -->
      <class-decl name='allocator&lt;MallocExtension::FreeListInfo&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-982'>
        <!-- class __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-988'/>
        <member-function access='private'>
          <!-- void std::allocator<MallocExtension::FreeListInfo>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<MallocExtension::FreeListInfo>::allocator(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<MallocExtension::FreeListInfo>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- const MallocExtension::FreeListInfo -->
    <qualified-type-def type-id='type-id-868' const='yes' id='type-id-977'/>
    <!-- const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >* -->
    <pointer-type-def type-id='type-id-990' size-in-bits='64' id='type-id-975'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-940' const='yes' id='type-id-978'/>
    <!-- const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-991' size-in-bits='64' id='type-id-986'/>
    <!-- const std::allocator<MallocExtension::FreeListInfo> -->
    <qualified-type-def type-id='type-id-982' const='yes' id='type-id-979'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
    <qualified-type-def type-id='type-id-951' const='yes' id='type-id-980'/>
    <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-958' size-in-bits='64' id='type-id-984'/>
    <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl* -->
    <pointer-type-def type-id='type-id-981' size-in-bits='64' id='type-id-983'/>
    <!-- std::allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-982' size-in-bits='64' id='type-id-985'/>
    <!-- MallocExtension::FreeListInfo* const -->
    <qualified-type-def type-id='type-id-969' const='yes' id='type-id-987'/>
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
      <class-decl name='new_allocator&lt;MallocExtension::FreeListInfo&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-988'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::new_allocator(const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-993'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::address(MallocExtension::FreeListInfo&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7addressERS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-968'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::address(const MallocExtension::FreeListInfo&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7addressERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- const MallocExtension::FreeListInfo* -->
            <return type-id='type-id-970'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::deallocate(MallocExtension::FreeListInfo*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE10deallocateEPS2_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::construct(MallocExtension::FreeListInfo*, const MallocExtension::FreeListInfo&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE9constructEPS2_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::destroy(MallocExtension::FreeListInfo*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7destroyEPS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
    <qualified-type-def type-id='type-id-963' const='yes' id='type-id-990'/>
    <!-- const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
    <qualified-type-def type-id='type-id-958' const='yes' id='type-id-991'/>
    <!-- std::allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-982' size-in-bits='64' id='type-id-989'/>
    <!-- __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-988' size-in-bits='64' id='type-id-992'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-995' size-in-bits='64' id='type-id-993'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-995' size-in-bits='64' id='type-id-994'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
    <qualified-type-def type-id='type-id-988' const='yes' id='type-id-995'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/heap-profile-table.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- HeapProfileTable::AllocValue::Bucket* const -->
    <qualified-type-def type-id='type-id-214' const='yes' id='type-id-866'/>
    <!-- HeapProfileTable::AllocValue::Bucket* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-866' size-in-bits='64' id='type-id-818'/>
    <!-- HeapProfileTable::AllocValue::Bucket* const* -->
    <pointer-type-def type-id='type-id-866' size-in-bits='64' id='type-id-890'/>
    <!-- HeapProfileTable::AllocValue::Bucket*& -->
    <reference-type-def kind='lvalue' type-id='type-id-214' size-in-bits='64' id='type-id-996'/>
    <!-- HeapProfileTable::Snapshot::Entry& -->
    <reference-type-def kind='lvalue' type-id='type-id-221' size-in-bits='64' id='type-id-819'/>
    <!-- HeapProfileTable::Snapshot::Entry* -->
    <pointer-type-def type-id='type-id-221' size-in-bits='64' id='type-id-222'/>
    <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-940' size-in-bits='64' id='type-id-953'/>
    <!-- __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-904' size-in-bits='64' id='type-id-937'/>
    <!-- bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)* -->
    <pointer-type-def type-id='type-id-997' size-in-bits='64' id='type-id-998'/>
    <!-- bool* -->
    <pointer-type-def type-id='type-id-55' size-in-bits='64' id='type-id-999'/>
    <!-- const HeapProfileBucket -->
    <qualified-type-def type-id='type-id-212' const='yes' id='type-id-1000'/>
    <!-- const HeapProfileBucket* -->
    <pointer-type-def type-id='type-id-1000' size-in-bits='64' id='type-id-1001'/>
    <!-- const HeapProfileTable::Snapshot::Entry -->
    <qualified-type-def type-id='type-id-221' const='yes' id='type-id-836'/>
    <!-- const HeapProfileTable::Snapshot::Entry& -->
    <reference-type-def kind='lvalue' type-id='type-id-836' size-in-bits='64' id='type-id-224'/>
    <!-- const HeapProfileTable::Snapshot::Entry* -->
    <pointer-type-def type-id='type-id-836' size-in-bits='64' id='type-id-223'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-940' const='yes' id='type-id-978'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-978' size-in-bits='64' id='type-id-954'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-978' size-in-bits='64' id='type-id-955'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-904' const='yes' id='type-id-972'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-972' size-in-bits='64' id='type-id-938'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-972' size-in-bits='64' id='type-id-939'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-806' const='yes' id='type-id-943'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-943' size-in-bits='64' id='type-id-888'/>
    <!-- const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-943' size-in-bits='64' id='type-id-885'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-815' const='yes' id='type-id-945'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-945' size-in-bits='64' id='type-id-918'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-945' size-in-bits='64' id='type-id-915'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-814' const='yes' id='type-id-946'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-946' size-in-bits='64' id='type-id-914'/>
    <!-- const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-946' size-in-bits='64' id='type-id-920'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-950' const='yes' id='type-id-947'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-947' size-in-bits='64' id='type-id-957'/>
    <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-947' size-in-bits='64' id='type-id-887'/>
    <!-- const std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-1002' const='yes' id='type-id-1003'/>
    <!-- const std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-1003' size-in-bits='64' id='type-id-1004'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-880' const='yes' id='type-id-948'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-948' size-in-bits='64' id='type-id-882'/>
    <!-- const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
    <qualified-type-def type-id='type-id-813' const='yes' id='type-id-908'/>
    <!-- const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-908' size-in-bits='64' id='type-id-809'/>
    <!-- const std::less<HeapProfileTable::Bucket*> -->
    <qualified-type-def type-id='type-id-822' const='yes' id='type-id-909'/>
    <!-- const std::less<HeapProfileTable::Bucket*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-909' size-in-bits='64' id='type-id-808'/>
    <!-- const std::less<HeapProfileTable::Bucket*>* -->
    <pointer-type-def type-id='type-id-909' size-in-bits='64' id='type-id-925'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
    <qualified-type-def type-id='type-id-226' const='yes' id='type-id-910'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-910' size-in-bits='64' id='type-id-810'/>
    <!-- const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-910' size-in-bits='64' id='type-id-812'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> -->
    <qualified-type-def type-id='type-id-949' const='yes' id='type-id-911'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
    <reference-type-def kind='lvalue' type-id='type-id-911' size-in-bits='64' id='type-id-820'/>
    <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
    <pointer-type-def type-id='type-id-911' size-in-bits='64' id='type-id-916'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-806' size-in-bits='64' id='type-id-889'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-806' size-in-bits='64' id='type-id-883'/>
    <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>* -->
    <pointer-type-def type-id='type-id-879' size-in-bits='64' id='type-id-881'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-815' size-in-bits='64' id='type-id-917'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-815' size-in-bits='64' id='type-id-913'/>
    <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-814' size-in-bits='64' id='type-id-923'/>
    <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-814' size-in-bits='64' id='type-id-919'/>
    <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-950' size-in-bits='64' id='type-id-956'/>
    <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-950' size-in-bits='64' id='type-id-886'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-880' size-in-bits='64' id='type-id-884'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-880' size-in-bits='64' id='type-id-941'/>
    <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
    <pointer-type-def type-id='type-id-813' size-in-bits='64' id='type-id-905'/>
    <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-226' size-in-bits='64' id='type-id-811'/>
    <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >* -->
    <pointer-type-def type-id='type-id-226' size-in-bits='64' id='type-id-807'/>
    <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
    <reference-type-def kind='lvalue' type-id='type-id-949' size-in-bits='64' id='type-id-921'/>
    <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
    <pointer-type-def type-id='type-id-949' size-in-bits='64' id='type-id-922'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>* -->
    <pointer-type-def type-id='type-id-821' size-in-bits='64' id='type-id-927'/>
    <!-- void (const HeapProfileBucket*, HeapProfileTable::BufferArgs*)* -->
    <pointer-type-def type-id='type-id-856' size-in-bits='64' id='type-id-203'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*)* -->
    <pointer-type-def type-id='type-id-859' size-in-bits='64' id='type-id-294'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*)* -->
    <pointer-type-def type-id='type-id-860' size-in-bits='64' id='type-id-295'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*)* -->
    <pointer-type-def type-id='type-id-861' size-in-bits='64' id='type-id-297'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, char*)* -->
    <pointer-type-def type-id='type-id-862' size-in-bits='64' id='type-id-293'/>
    <!-- void (void*, HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&)* -->
    <pointer-type-def type-id='type-id-863' size-in-bits='64' id='type-id-296'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- class std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-880'>
        <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-940'/>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocator(const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-882'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-941' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::less<HeapProfileTable::Bucket*> -->
      <class-decl name='less&lt;HeapProfileTable::Bucket*&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='227' column='1' id='type-id-822'>
        <!-- struct std::binary_function<HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-924'/>
        <member-function access='public'>
          <!-- bool std::less<HeapProfileTable::Bucket*>::operator()(HeapProfileTable::AllocValue::Bucket* const&, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt4lessIP17HeapProfileBucketEclERKS1_S4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::less<HeapProfileTable::Bucket*>*' -->
            <parameter type-id='type-id-925' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::binary_function<HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool> -->
      <class-decl name='binary_function&lt;HeapProfileTable::Bucket*, HeapProfileTable::Bucket*, bool&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='113' column='1' id='type-id-924'/>
      <!-- class std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='_Rb_tree&lt;HeapProfileTable::Bucket*, std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt;, std::_Select1st&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::less&lt;HeapProfileTable::Bucket*&gt;, std::allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-806'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;HeapProfileTable::Bucket*&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-879'>
            <!-- class std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-880'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<HeapProfileTable::Bucket*> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-822' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_Rb_tree_impl(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
                <parameter type-id='type-id-808'/>
                <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
                <parameter type-id='type-id-882'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13_Rb_tree_implISB_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false>*' -->
                <parameter type-id='type-id-881' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree_impl<std::less<HeapProfileTable::Bucket*>, false> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-879' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-884'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-882'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-813'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_put_node(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_put_nodeEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_create_node(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_create_nodeERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_destroy_node(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_clone_node(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_valueEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_S_keyEPKSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_M_insert_EPKSt18_Rb_tree_node_baseSG_RKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE10_M_insert_EPKSt18_Rb_tree_node_baseSG_RKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_insert_lowerEPSt18_Rb_tree_node_baseSF_RKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal_lower(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE21_M_insert_equal_lowerERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_copy(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE7_M_copyEPKSt13_Rb_tree_nodeIS7_EPSF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_erase(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_eraseEPSt13_Rb_tree_nodeIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8_M_eraseEPSt13_Rb_tree_nodeIS7_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_lower_bound(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_lower_boundEPSt13_Rb_tree_nodeIS7_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_lower_bound(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_lower_boundEPKSt13_Rb_tree_nodeIS7_ESH_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_upper_bound(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_upper_boundEPSt13_Rb_tree_nodeIS7_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_upper_bound(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE14_M_upper_boundEPKSt13_Rb_tree_nodeIS7_ESH_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
            <parameter type-id='type-id-808'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_Rb_tree(const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-888'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator=(const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EEaSERKSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-888'/>
            <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-889'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<HeapProfileTable::Bucket*> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::less<HeapProfileTable::Bucket*> -->
            <return type-id='type-id-822'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::swap(std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4swapERSD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-889'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_uniqueERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_uniqueERKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
            <return type-id='type-id-821'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE15_M_insert_equalERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS7_ERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS7_ERKS7_'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS7_ERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt17_Rb_tree_iteratorIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt23_Rb_tree_const_iteratorIS7_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt17_Rb_tree_iteratorIS7_ESF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseESt23_Rb_tree_const_iteratorIS7_ESF_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-815'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const*, HeapProfileTable::AllocValue::Bucket* const*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5eraseEPS3_SE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::count(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE5countERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-883' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-823'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-824'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeIP17HeapProfileBucketSt4pairIKS1_N16HeapProfileTable8Snapshot5EntryEESt10_Select1stIS7_ESt4lessIS1_ESaIS7_EE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-885' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-813'>
        <!-- class __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-904'/>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator(const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >(const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-905' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-882'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__equal<false> -->
      <class-decl name='__equal&lt;false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='796' column='1' id='type-id-1005'>
        <member-function access='public' static='yes'>
          <!-- bool std::__equal<false>::equal<const void* const*, const void**>(void* const*, void**) -->
          <function-decl name='equal&lt;const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- bool std::__equal<false>::equal<const void**, const void**>(void**, void**) -->
          <function-decl name='equal&lt;const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<const void**, false> -->
      <class-decl name='__niter_base&lt;const void**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-1006'>
        <member-function access='public' static='yes'>
          <!-- void** std::__niter_base<const void**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPPKvLb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<const void* const*, false> -->
      <class-decl name='__niter_base&lt;const void* const*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-1007'>
        <member-function access='public' static='yes'>
          <!-- void* const* std::__niter_base<const void* const*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPKPKvLb0EE3__bES3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- void* const* -->
            <return type-id='type-id-173'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-814'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-921'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-923'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-923'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-919' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator==(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEeqERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator!=(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEneERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-920' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> -->
      <class-decl name='pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-949'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- HeapProfileTable::AllocValue::Bucket* const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::first -->
          <var-decl name='first' type-id='type-id-866' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- HeapProfileTable::Snapshot::Entry std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::second -->
          <var-decl name='second' type-id='type-id-221' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>::pair(HeapProfileTable::AllocValue::Bucket* const&, const HeapProfileTable::Snapshot::Entry&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
            <parameter type-id='type-id-224'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<const void* const*, false> -->
      <class-decl name='__miter_base&lt;const void* const*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-1008'>
        <member-function access='public' static='yes'>
          <!-- void* const* std::__miter_base<const void* const*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPKPKvLb0EE3__bES3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- void* const* -->
            <return type-id='type-id-173'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Select1st&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='482' column='1' id='type-id-1002'>
        <!-- struct std::unary_function<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, HeapProfileTable::Bucket* const> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1009'/>
        <member-function access='public'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator()(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEclERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-1004' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-921'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- HeapProfileTable::AllocValue::Bucket* const& std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator()(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEclERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-1004' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- HeapProfileTable::AllocValue::Bucket* const& -->
            <return type-id='type-id-818'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, HeapProfileTable::Bucket* const> -->
      <class-decl name='unary_function&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt;, HeapProfileTable::Bucket* const&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-1009'/>
      <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='map&lt;HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less&lt;HeapProfileTable::Bucket*&gt;, std::allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-226'>
        <member-type access='private'>
          <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-805'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<HeapProfileTable::Bucket*, std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>, std::_Select1st<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-806' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map(const std::less<HeapProfileTable::Bucket*>&, const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<HeapProfileTable::Bucket*>&' -->
            <parameter type-id='type-id-808'/>
            <!-- parameter of type 'const std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-809'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::map(const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-810'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator=(const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEEaSERKSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-810'/>
            <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >& -->
            <return type-id='type-id-811'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-813'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-816'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-817'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::operator[](HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEEixERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-819'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::at(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE2atERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-819'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const HeapProfileTable::Snapshot::Entry& std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::at(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE2atERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- const HeapProfileTable::Snapshot::Entry& -->
            <return type-id='type-id-224'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::insert(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6insertERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
            <return type-id='type-id-821'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::insert(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE6insertESt17_Rb_tree_iteratorIS9_ERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseESt17_Rb_tree_iteratorIS9_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::erase(std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5eraseESt17_Rb_tree_iteratorIS9_ESD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >' -->
            <parameter type-id='type-id-814'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::swap(std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4swapERSB_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-811'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<HeapProfileTable::Bucket*> std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- struct std::less<HeapProfileTable::Bucket*> -->
            <return type-id='type-id-822'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- class std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::value_compare -->
            <return type-id='type-id-805'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::find(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE4findERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::count(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE5countERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::lower_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11lower_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-814'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::upper_bound(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11upper_boundERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-807' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-823'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::equal_range(HeapProfileTable::AllocValue::Bucket* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapIP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryESt4lessIS1_ESaISt4pairIKS1_S4_EEE11equal_rangeERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<HeapProfileTable::Bucket*, HeapProfileTable::Snapshot::Entry, std::less<HeapProfileTable::Bucket*>, std::allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-812' is-artificial='yes'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
            <parameter type-id='type-id-818'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
            <return type-id='type-id-824'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__iter_swap<true> -->
      <class-decl name='__iter_swap&lt;true&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='96' column='1' id='type-id-1010'>
        <member-function access='public' static='yes'>
          <!-- void std::__iter_swap<true>::iter_swap<HeapProfileTable::Bucket**, HeapProfileTable::Bucket**>(HeapProfileTable::AllocValue::Bucket**) -->
          <function-decl name='iter_swap&lt;HeapProfileTable::Bucket**, HeapProfileTable::Bucket**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
            <parameter type-id='type-id-248'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
            <parameter type-id='type-id-248'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void std::__iter_swap<true>::iter_swap<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*) -->
          <function-decl name='iter_swap&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<HeapProfileTable::Snapshot::Entry*, false> -->
      <class-decl name='__niter_base&lt;HeapProfileTable::Snapshot::Entry*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-1011'>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::Snapshot::Entry* std::__niter_base<HeapProfileTable::Snapshot::Entry*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPN16HeapProfileTable8Snapshot5EntryELb0EE3__bES3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- HeapProfileTable::Snapshot::Entry* -->
            <return type-id='type-id-222'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<HeapProfileTable::Snapshot::Entry*, false> -->
      <class-decl name='__miter_base&lt;HeapProfileTable::Snapshot::Entry*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-1012'>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::Snapshot::Entry* std::__miter_base<HeapProfileTable::Snapshot::Entry*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPN16HeapProfileTable8Snapshot5EntryELb0EE3__bES3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
            <parameter type-id='type-id-222'/>
            <!-- HeapProfileTable::Snapshot::Entry* -->
            <return type-id='type-id-222'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-821'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::first -->
          <var-decl name='first' type-id='type-id-814' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>*' -->
            <parameter type-id='type-id-927' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>::pair(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, bool>*' -->
            <parameter type-id='type-id-927' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-815'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-887'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-914'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>& -->
            <return type-id='type-id-820'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-916'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-917'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >& -->
            <return type-id='type-id-917'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-913' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
            <return type-id='type-id-815'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator==(const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEeqERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-918'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::operator!=(const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEneERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-915' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-918'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<HeapProfileTable::Bucket**, false> -->
      <class-decl name='__niter_base&lt;HeapProfileTable::Bucket**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-1013'>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket** std::__niter_base<HeapProfileTable::Bucket**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPP17HeapProfileBucketLb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
            <parameter type-id='type-id-248'/>
            <!-- HeapProfileTable::AllocValue::Bucket** -->
            <return type-id='type-id-248'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<HeapProfileTable::Bucket**, false> -->
      <class-decl name='__miter_base&lt;HeapProfileTable::Bucket**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-1014'>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket** std::__miter_base<HeapProfileTable::Bucket**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPP17HeapProfileBucketLb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
            <parameter type-id='type-id-248'/>
            <!-- HeapProfileTable::AllocValue::Bucket** -->
            <return type-id='type-id-248'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- bool std::__equal_aux<const void* const*, const void**>(void* const*, void* const*, void**) -->
      <function-decl name='__equal_aux&lt;const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='822' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void std::__unguarded_linear_insert<HeapProfileTable::Bucket**, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket*, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__unguarded_linear_insert&lt;HeapProfileTable::Bucket**, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2079' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*' -->
        <parameter type-id='type-id-214'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__unguarded_linear_insert<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry) -->
      <function-decl name='__unguarded_linear_insert&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2063' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'struct HeapProfileTable::Snapshot::Entry' -->
        <parameter type-id='type-id-221'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::swap<HeapProfileTable::Bucket*>(HeapProfileTable::AllocValue::Bucket*&, HeapProfileTable::AllocValue::Bucket*&) -->
      <function-decl name='swap&lt;HeapProfileTable::Bucket*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/move.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*&' -->
        <parameter type-id='type-id-996'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*&' -->
        <parameter type-id='type-id-996'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::iter_swap<HeapProfileTable::Bucket**, HeapProfileTable::Bucket**>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**) -->
      <function-decl name='iter_swap&lt;HeapProfileTable::Bucket**, HeapProfileTable::Bucket**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::swap<HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry&, HeapProfileTable::Snapshot::Entry&) -->
      <function-decl name='swap&lt;HeapProfileTable::Snapshot::Entry&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/move.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry&' -->
        <parameter type-id='type-id-819'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry&' -->
        <parameter type-id='type-id-819'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::iter_swap<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='iter_swap&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__push_heap<HeapProfileTable::Bucket**, long int, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, long int, long int, HeapProfileTable::AllocValue::Bucket*, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__push_heap&lt;HeapProfileTable::Bucket**, long int, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='176' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*' -->
        <parameter type-id='type-id-214'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::make_heap<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='make_heap&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__pop_heap<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__pop_heap&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='322' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::sort_heap<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='sort_heap&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='482' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::partial_sort<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='partial_sort&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='5095' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- HeapProfileTable::AllocValue::Bucket* const& std::__median<HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket* const&, HeapProfileTable::AllocValue::Bucket* const&, HeapProfileTable::AllocValue::Bucket* const&, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__median&lt;HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
        <parameter type-id='type-id-818'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
        <parameter type-id='type-id-818'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const&' -->
        <parameter type-id='type-id-818'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- HeapProfileTable::AllocValue::Bucket* const& -->
        <return type-id='type-id-818'/>
      </function-decl>
      <!-- HeapProfileTable::AllocValue::Bucket** std::__unguarded_partition<HeapProfileTable::Bucket**, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket*, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__unguarded_partition&lt;HeapProfileTable::Bucket**, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2224' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*' -->
        <parameter type-id='type-id-214'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- HeapProfileTable::AllocValue::Bucket** -->
        <return type-id='type-id-248'/>
      </function-decl>
      <!-- void std::__push_heap<HeapProfileTable::Snapshot::Entry*, long int, HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry*, long int, long int, HeapProfileTable::Snapshot::Entry) -->
      <function-decl name='__push_heap&lt;HeapProfileTable::Snapshot::Entry*, long int, HeapProfileTable::Snapshot::Entry&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='130' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'struct HeapProfileTable::Snapshot::Entry' -->
        <parameter type-id='type-id-221'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::make_heap<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='make_heap&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='373' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__heap_select<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__heap_select&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='1900' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::sort_heap<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='sort_heap&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::partial_sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='partial_sort&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='5055' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- const HeapProfileTable::Snapshot::Entry& std::__median<HeapProfileTable::Snapshot::Entry>(const HeapProfileTable::Snapshot::Entry&, const HeapProfileTable::Snapshot::Entry&, const HeapProfileTable::Snapshot::Entry&) -->
      <function-decl name='__median&lt;HeapProfileTable::Snapshot::Entry&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
        <parameter type-id='type-id-224'/>
        <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
        <parameter type-id='type-id-224'/>
        <!-- parameter of type 'const HeapProfileTable::Snapshot::Entry&' -->
        <parameter type-id='type-id-224'/>
        <!-- const HeapProfileTable::Snapshot::Entry& -->
        <return type-id='type-id-224'/>
      </function-decl>
      <!-- HeapProfileTable::Snapshot::Entry* std::__unguarded_partition<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry) -->
      <function-decl name='__unguarded_partition&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2204' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'struct HeapProfileTable::Snapshot::Entry' -->
        <parameter type-id='type-id-221'/>
        <!-- HeapProfileTable::Snapshot::Entry* -->
        <return type-id='type-id-222'/>
      </function-decl>
      <!-- HeapProfileTable::Snapshot::Entry* std::__copy_move_backward_a<false, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__copy_move_backward_a&lt;false, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- HeapProfileTable::Snapshot::Entry* -->
        <return type-id='type-id-222'/>
      </function-decl>
      <!-- HeapProfileTable::Snapshot::Entry* std::__copy_move_backward_a2<false, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__copy_move_backward_a2&lt;false, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- HeapProfileTable::Snapshot::Entry* -->
        <return type-id='type-id-222'/>
      </function-decl>
      <!-- HeapProfileTable::Snapshot::Entry* std::copy_backward<HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='copy_backward&lt;HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- HeapProfileTable::Snapshot::Entry* -->
        <return type-id='type-id-222'/>
      </function-decl>
      <!-- void std::__unguarded_insertion_sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__unguarded_insertion_sort&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2141' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- long int std::__lg(long int) -->
      <function-decl name='__lg' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2323' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- long int -->
        <return type-id='type-id-80'/>
      </function-decl>
      <!-- void std::__final_insertion_sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__final_insertion_sort&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2173' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='sort&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='5207' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- HeapProfileTable::AllocValue::Bucket** std::__copy_move_backward_a<false, HeapProfileTable::Bucket**, HeapProfileTable::Bucket**>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**) -->
      <function-decl name='__copy_move_backward_a&lt;false, HeapProfileTable::Bucket**, HeapProfileTable::Bucket**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- HeapProfileTable::AllocValue::Bucket** -->
        <return type-id='type-id-248'/>
      </function-decl>
      <!-- HeapProfileTable::AllocValue::Bucket** std::__copy_move_backward_a2<false, HeapProfileTable::Bucket**, HeapProfileTable::Bucket**>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**) -->
      <function-decl name='__copy_move_backward_a2&lt;false, HeapProfileTable::Bucket**, HeapProfileTable::Bucket**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- HeapProfileTable::AllocValue::Bucket** -->
        <return type-id='type-id-248'/>
      </function-decl>
      <!-- HeapProfileTable::AllocValue::Bucket** std::copy_backward<HeapProfileTable::Bucket**, HeapProfileTable::Bucket**>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**) -->
      <function-decl name='copy_backward&lt;HeapProfileTable::Bucket**, HeapProfileTable::Bucket**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- HeapProfileTable::AllocValue::Bucket** -->
        <return type-id='type-id-248'/>
      </function-decl>
      <!-- void std::__unguarded_insertion_sort<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__unguarded_insertion_sort&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2154' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__final_insertion_sort<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__final_insertion_sort&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2188' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::sort<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='sort&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='5244' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void** std::__copy_move_a<false, const void* const*, const void**>(void* const*, void* const*, void**) -->
      <function-decl name='__copy_move_a&lt;false, const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::__copy_move_a2<false, const void* const*, const void**>(void* const*, void* const*, void**) -->
      <function-decl name='__copy_move_a2&lt;false, const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- bool std::equal<const void* const*, const void**>(void* const*, void* const*, void**) -->
      <function-decl name='equal&lt;const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='952' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void** std::copy<const void* const*, const void**>(void* const*, void* const*, void**) -->
      <function-decl name='copy&lt;const void* const*, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void* const*' -->
        <parameter type-id='type-id-173'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void std::__insertion_sort<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__insertion_sort&lt;HeapProfileTable::Snapshot::Entry*&gt;' mangled-name='_ZSt16__insertion_sortIPN16HeapProfileTable8Snapshot5EntryEEvT_S4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2096' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt16__insertion_sortIPN16HeapProfileTable8Snapshot5EntryEEvT_S4_'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__adjust_heap<HeapProfileTable::Bucket**, long int, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, long int, long int, HeapProfileTable::AllocValue::Bucket*, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__adjust_heap&lt;HeapProfileTable::Bucket**, long int, HeapProfileTable::Bucket*, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' mangled-name='_ZSt13__adjust_heapIPP17HeapProfileBucketlS1_PFbP16HeapProfileStatsS4_EEvT_T0_S8_T1_T2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt13__adjust_heapIPP17HeapProfileBucketlS1_PFbP16HeapProfileStatsS4_EEvT_T0_S8_T1_T2_'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket*' -->
        <parameter type-id='type-id-214'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__heap_select<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__heap_select&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' mangled-name='_ZSt13__heap_selectIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_S7_T0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='1913' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt13__heap_selectIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_S7_T0_'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__introsort_loop<HeapProfileTable::Bucket**, long int, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, long int, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__introsort_loop&lt;HeapProfileTable::Bucket**, long int, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' mangled-name='_ZSt16__introsort_loopIPP17HeapProfileBucketlPFbP16HeapProfileStatsS4_EEvT_S7_T0_T1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2277' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt16__introsort_loopIPP17HeapProfileBucketlPFbP16HeapProfileStatsS4_EEvT_S7_T0_T1_'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__adjust_heap<HeapProfileTable::Snapshot::Entry*, long int, HeapProfileTable::Snapshot::Entry>(HeapProfileTable::Snapshot::Entry*, long int, long int, HeapProfileTable::Snapshot::Entry) -->
      <function-decl name='__adjust_heap&lt;HeapProfileTable::Snapshot::Entry*, long int, HeapProfileTable::Snapshot::Entry&gt;' mangled-name='_ZSt13__adjust_heapIPN16HeapProfileTable8Snapshot5EntryElS2_EvT_T0_S5_T1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='224' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt13__adjust_heapIPN16HeapProfileTable8Snapshot5EntryElS2_EvT_T0_S5_T1_'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- parameter of type 'struct HeapProfileTable::Snapshot::Entry' -->
        <parameter type-id='type-id-221'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__pop_heap<HeapProfileTable::Snapshot::Entry*>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*) -->
      <function-decl name='__pop_heap&lt;HeapProfileTable::Snapshot::Entry*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_heap.h' line='250' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__introsort_loop<HeapProfileTable::Snapshot::Entry*, long int>(HeapProfileTable::Snapshot::Entry*, HeapProfileTable::Snapshot::Entry*, long int) -->
      <function-decl name='__introsort_loop&lt;HeapProfileTable::Snapshot::Entry*, long int&gt;' mangled-name='_ZSt16__introsort_loopIPN16HeapProfileTable8Snapshot5EntryElEvT_S4_T0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2245' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt16__introsort_loopIPN16HeapProfileTable8Snapshot5EntryElEvT_S4_T0_'>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'HeapProfileTable::Snapshot::Entry*' -->
        <parameter type-id='type-id-222'/>
        <!-- parameter of type 'long int' -->
        <parameter type-id='type-id-80'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::__insertion_sort<HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)>(HeapProfileTable::AllocValue::Bucket**, HeapProfileTable::AllocValue::Bucket**, bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*) -->
      <function-decl name='__insertion_sort&lt;HeapProfileTable::Bucket**, bool (*)(HeapProfileTable::Stats*, HeapProfileTable::Stats*)&gt;' mangled-name='_ZSt16__insertion_sortIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_T0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h' line='2119' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZSt16__insertion_sortIPP17HeapProfileBucketPFbP16HeapProfileStatsS4_EEvT_S7_T0_'>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
        <parameter type-id='type-id-248'/>
        <!-- parameter of type 'bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*)*' -->
        <parameter type-id='type-id-998'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- struct std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-950'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-816'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-817'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-823'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >, std::_Rb_tree_const_iterator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-824'/>
    </namespace-decl>
    <!-- namespace __gnu_cxx -->
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > > -->
      <class-decl name='new_allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-940'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::new_allocator(const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >&' -->
            <parameter type-id='type-id-954'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::address(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7addressERSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-956'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::address(const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7addressERKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-957'/>
            <!-- const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-887'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >* -->
            <return type-id='type-id-886'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::deallocate(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE10deallocateEPSA_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-955' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::construct(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*, const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE9constructEPSA_RKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-957'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >::destroy(std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEEE7destroyEPSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > >*' -->
            <parameter type-id='type-id-953' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-886'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> > -->
      <class-decl name='new_allocator&lt;std::pair&lt;HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-904'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::new_allocator(const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >&' -->
            <parameter type-id='type-id-938'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::address(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7addressERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-921'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::address(const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7addressERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-916'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>* -->
            <return type-id='type-id-922'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::deallocate(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE10deallocateEPS8_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-939' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::construct(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*, const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE9constructEPS8_RKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- parameter of type 'const std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>&' -->
            <parameter type-id='type-id-820'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >::destroy(std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKP17HeapProfileBucketN16HeapProfileTable8Snapshot5EntryEEE7destroyEPS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry> >*' -->
            <parameter type-id='type-id-937' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<HeapProfileTable::Bucket* const, HeapProfileTable::Snapshot::Entry>*' -->
            <parameter type-id='type-id-922'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead'>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_heap_check_max_leaks -->
      <var-decl name='FLAGS_heap_check_max_leaks' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead26FLAGS_heap_check_max_leaksE' visibility='default' filepath='src/heap-profile-table.cc' line='87' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead26FLAGS_heap_check_max_leaksE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_noheap_check_max_leaks -->
      <var-decl name='FLAGS_noheap_check_max_leaks' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead28FLAGS_noheap_check_max_leaksE' visibility='default' filepath='src/heap-profile-table.cc' line='89' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead28FLAGS_noheap_check_max_leaksE'/>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- int tcmalloc::FillProcSelfMaps(char*, int, bool*) -->
      <function-decl name='FillProcSelfMaps' mangled-name='_ZN8tcmalloc16FillProcSelfMapsEPciPb' filepath='src/base/sysinfo.h' line='232' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc16FillProcSelfMapsEPciPb'>
        <!-- parameter of type 'char*' -->
        <parameter type-id='type-id-113'/>
        <!-- parameter of type 'int' -->
        <parameter type-id='type-id-1'/>
        <!-- parameter of type 'bool*' -->
        <parameter type-id='type-id-999'/>
        <!-- int -->
        <return type-id='type-id-1'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_cleanup_old_heap_profiles -->
      <var-decl name='FLAGS_cleanup_old_heap_profiles' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_cleanup_old_heap_profilesE' visibility='default' filepath='src/heap-profile-table.cc' line='83' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead31FLAGS_cleanup_old_heap_profilesE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nocleanup_old_heap_profiles -->
      <var-decl name='FLAGS_nocleanup_old_heap_profiles' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_nocleanup_old_heap_profilesE' visibility='default' filepath='src/heap-profile-table.cc' line='85' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead33FLAGS_nocleanup_old_heap_profilesE'/>
    </namespace-decl>
    <!-- bool (HeapProfileTable::DumpArgs::Stats*, HeapProfileTable::DumpArgs::Stats*) -->
    <function-type size-in-bits='64' id='type-id-997'>
      <!-- parameter of type 'HeapProfileTable::DumpArgs::Stats*' -->
      <parameter type-id='type-id-218'/>
      <!-- parameter of type 'HeapProfileTable::DumpArgs::Stats*' -->
      <parameter type-id='type-id-218'/>
      <!-- bool -->
      <return type-id='type-id-55'/>
    </function-type>
    <!-- void (const HeapProfileBucket*, HeapProfileTable::BufferArgs*) -->
    <function-type size-in-bits='64' id='type-id-856'>
      <!-- parameter of type 'const HeapProfileBucket*' -->
      <parameter type-id='type-id-1001'/>
      <!-- parameter of type 'HeapProfileTable::BufferArgs*' -->
      <parameter type-id='type-id-204'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::AddNonLiveArgs*) -->
    <function-type size-in-bits='64' id='type-id-859'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'HeapProfileTable::AddNonLiveArgs*' -->
      <parameter type-id='type-id-257'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot*) -->
    <function-type size-in-bits='64' id='type-id-860'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'HeapProfileTable::Snapshot*' -->
      <parameter type-id='type-id-230'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, HeapProfileTable::Snapshot::ReportState*) -->
    <function-type size-in-bits='64' id='type-id-861'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'HeapProfileTable::Snapshot::ReportState*' -->
      <parameter type-id='type-id-234'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, char*) -->
    <function-type size-in-bits='64' id='type-id-862'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, HeapProfileTable::AllocValue*, const HeapProfileTable::DumpArgs&) -->
    <function-type size-in-bits='64' id='type-id-863'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'HeapProfileTable::AllocValue*' -->
      <parameter type-id='type-id-215'/>
      <!-- parameter of type 'const HeapProfileTable::DumpArgs&' -->
      <parameter type-id='type-id-256'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/heap-profiler.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- struct HeapProfileEndWriter -->
    <class-decl name='HeapProfileEndWriter' size-in-bits='8' is-struct='yes' visibility='default' filepath='src/heap-profiler.cc' line='593' column='1' id='type-id-1015'>
      <member-function access='public' destructor='yes'>
        <!-- HeapProfileEndWriter::~HeapProfileEndWriter(int) -->
        <function-decl name='~HeapProfileEndWriter' mangled-name='_ZN20HeapProfileEndWriterD1Ev' filepath='src/heap-profiler.cc' line='594' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN20HeapProfileEndWriterD1Ev'>
          <!-- implicit parameter of type 'HeapProfileEndWriter*' -->
          <parameter type-id='type-id-1016' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- HeapProfileEndWriter* -->
    <pointer-type-def type-id='type-id-1015' size-in-bits='64' id='type-id-1016'/>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_allocation_interval -->
      <var-decl name='FLAGS_heap_profile_allocation_interval' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead38FLAGS_heap_profile_allocation_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='95' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead38FLAGS_heap_profile_allocation_intervalE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_allocation_interval -->
      <var-decl name='FLAGS_noheap_profile_allocation_interval' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_noheap_profile_allocation_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='99' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_noheap_profile_allocation_intervalE'/>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_deallocation_interval -->
      <var-decl name='FLAGS_heap_profile_deallocation_interval' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_heap_profile_deallocation_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='100' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead40FLAGS_heap_profile_deallocation_intervalE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_deallocation_interval -->
      <var-decl name='FLAGS_noheap_profile_deallocation_interval' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead42FLAGS_noheap_profile_deallocation_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='104' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead42FLAGS_noheap_profile_deallocation_intervalE'/>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_inuse_interval -->
      <var-decl name='FLAGS_heap_profile_inuse_interval' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_heap_profile_inuse_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='107' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_heap_profile_inuse_intervalE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_inuse_interval -->
      <var-decl name='FLAGS_noheap_profile_inuse_interval' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_noheap_profile_inuse_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='111' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead35FLAGS_noheap_profile_inuse_intervalE'/>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_heap_profile_time_interval -->
      <var-decl name='FLAGS_heap_profile_time_interval' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead32FLAGS_heap_profile_time_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='112' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead32FLAGS_heap_profile_time_intervalE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_noheap_profile_time_interval -->
      <var-decl name='FLAGS_noheap_profile_time_interval' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead34FLAGS_noheap_profile_time_intervalE' visibility='default' filepath='src/heap-profiler.cc' line='115' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead34FLAGS_noheap_profile_time_intervalE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_mmap_log -->
      <var-decl name='FLAGS_mmap_log' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead14FLAGS_mmap_logE' visibility='default' filepath='src/heap-profiler.cc' line='116' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead14FLAGS_mmap_logE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nommap_log -->
      <var-decl name='FLAGS_nommap_log' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead16FLAGS_nommap_logE' visibility='default' filepath='src/heap-profiler.cc' line='118' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead16FLAGS_nommap_logE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_mmap_profile -->
      <var-decl name='FLAGS_mmap_profile' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead18FLAGS_mmap_profileE' visibility='default' filepath='src/heap-profiler.cc' line='119' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead18FLAGS_mmap_profileE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nommap_profile -->
      <var-decl name='FLAGS_nommap_profile' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead20FLAGS_nommap_profileE' visibility='default' filepath='src/heap-profiler.cc' line='121' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead20FLAGS_nommap_profileE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_only_mmap_profile -->
      <var-decl name='FLAGS_only_mmap_profile' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_only_mmap_profileE' visibility='default' filepath='src/heap-profiler.cc' line='122' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead23FLAGS_only_mmap_profileE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_noonly_mmap_profile -->
      <var-decl name='FLAGS_noonly_mmap_profile' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noonly_mmap_profileE' visibility='default' filepath='src/heap-profiler.cc' line='125' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead25FLAGS_noonly_mmap_profileE'/>
    </namespace-decl>
    <!-- void HeapProfilerDump(const char*) -->
    <function-decl name='HeapProfilerDump' mangled-name='HeapProfilerDump' filepath='src/heap-profiler.cc' line='533' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='HeapProfilerDump'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='reason' filepath='src/heap-profiler.cc' line='533' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int IsHeapProfilerRunning() -->
    <function-decl name='IsHeapProfilerRunning' mangled-name='IsHeapProfilerRunning' filepath='src/heap-profiler.cc' line='487' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='IsHeapProfilerRunning'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- char* GetHeapProfile() -->
    <function-decl name='GetHeapProfile' mangled-name='GetHeapProfile' filepath='src/heap-profiler.cc' line='210' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='GetHeapProfile'>
      <!-- char* -->
      <return type-id='type-id-113'/>
    </function-decl>
    <!-- void HeapProfilerStop() -->
    <function-decl name='HeapProfilerStop' mangled-name='HeapProfilerStop' filepath='src/heap-profiler.cc' line='492' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='HeapProfilerStop'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void HeapProfilerStart(const char*) -->
    <function-decl name='HeapProfilerStart' mangled-name='HeapProfilerStart' filepath='src/heap-profiler.cc' line='421' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='HeapProfilerStart'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='reason' filepath='src/heap-profiler.cc' line='533' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/internal_logging.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- char[200] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='1600' id='type-id-1017'>
      <!-- <anonymous range>[200] -->
      <subrange length='200' type-id='type-id-5' id='type-id-1018'/>
    </array-type-def>
    <!-- const tcmalloc::LogItem -->
    <qualified-type-def type-id='type-id-1019' const='yes' id='type-id-1020'/>
    <!-- const tcmalloc::LogItem& -->
    <reference-type-def kind='lvalue' type-id='type-id-1020' size-in-bits='64' id='type-id-1021'/>
    <!-- tcmalloc::Logger* -->
    <pointer-type-def type-id='type-id-1022' size-in-bits='64' id='type-id-1023'/>
    <!-- void (const char*, int)* -->
    <pointer-type-def type-id='type-id-1024' size-in-bits='64' id='type-id-1025'/>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- class tcmalloc::Logger -->
      <class-decl name='Logger' size-in-bits='1728' visibility='default' filepath='src/internal_logging.cc' line='66' column='1' id='type-id-1022'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::Logger::kBufSize -->
          <var-decl name='kBufSize' type-id='type-id-134' visibility='default' filepath='src/internal_logging.cc' line='72' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::Logger::p_ -->
          <var-decl name='p_' type-id='type-id-113' visibility='default' filepath='src/internal_logging.cc' line='73' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- char* tcmalloc::Logger::end_ -->
          <var-decl name='end_' type-id='type-id-113' visibility='default' filepath='src/internal_logging.cc' line='74' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- char tcmalloc::Logger::buf_[200] -->
          <var-decl name='buf_' type-id='type-id-1017' visibility='default' filepath='src/internal_logging.cc' line='75' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- bool tcmalloc::Logger::Add(const tcmalloc::LogItem&) -->
          <function-decl name='Add' mangled-name='_ZN8tcmalloc6Logger3AddERKNS_7LogItemE' filepath='src/internal_logging.cc' line='68' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc6Logger3AddERKNS_7LogItemE'>
            <!-- implicit parameter of type 'tcmalloc::Logger*' -->
            <parameter type-id='type-id-1023' is-artificial='yes'/>
            <!-- parameter of type 'const tcmalloc::LogItem&' -->
            <parameter type-id='type-id-1021'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::Logger::AddStr(const char*, int) -->
          <function-decl name='AddStr' mangled-name='_ZN8tcmalloc6Logger6AddStrEPKci' filepath='src/internal_logging.cc' line='69' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc6Logger6AddStrEPKci'>
            <!-- implicit parameter of type 'tcmalloc::Logger*' -->
            <parameter type-id='type-id-1023' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::Logger::AddNum(uint64_t, int) -->
          <function-decl name='AddNum' mangled-name='_ZN8tcmalloc6Logger6AddNumEmi' filepath='src/internal_logging.cc' line='70' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc6Logger6AddNumEmi'>
            <!-- implicit parameter of type 'tcmalloc::Logger*' -->
            <parameter type-id='type-id-1023' is-artificial='yes'/>
            <!-- parameter of type 'typedef uint64_t' -->
            <parameter type-id='type-id-15'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- void (const char*, int)* tcmalloc::log_message_writer -->
      <var-decl name='log_message_writer' type-id='type-id-1025' mangled-name='_ZN8tcmalloc18log_message_writerE' visibility='default' filepath='src/internal_logging.cc' line='63' column='1' elf-symbol-id='_ZN8tcmalloc18log_message_writerE'/>
    </namespace-decl>
    <namespace-decl name='tcmalloc'>
      <!-- class tcmalloc::LogItem -->
      <class-decl name='LogItem' size-in-bits='128' visibility='default' filepath='src/internal_logging.h' line='70' column='1' id='type-id-1019'>
        <member-type access='private'>
          <!-- enum tcmalloc::LogItem::Tag -->
          <enum-decl name='Tag' filepath='src/internal_logging.h' line='83' column='1' id='type-id-1026'>
            <underlying-type type-id='type-id-84'/>
            <enumerator name='kStr' value='0'/>
            <enumerator name='kSigned' value='1'/>
            <enumerator name='kUnsigned' value='2'/>
            <enumerator name='kPtr' value='3'/>
            <enumerator name='kEnd' value='4'/>
          </enum-decl>
        </member-type>
        <member-type access='private'>
          <!-- union {const char* str; void* ptr; int64_t snum; uint64_t unum;} -->
          <union-decl name='__anonymous_union__' size-in-bits='64' is-anonymous='yes' visibility='default' filepath='src/internal_logging.h' line='91' column='1' id='type-id-1027'>
            <data-member access='private'>
              <!-- const char* str -->
              <var-decl name='str' type-id='type-id-52' visibility='default' filepath='src/internal_logging.h' line='92' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- void* ptr -->
              <var-decl name='ptr' type-id='type-id-53' visibility='default' filepath='src/internal_logging.h' line='93' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- int64_t snum -->
              <var-decl name='snum' type-id='type-id-98' visibility='default' filepath='src/internal_logging.h' line='94' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- uint64_t unum -->
              <var-decl name='unum' type-id='type-id-15' visibility='default' filepath='src/internal_logging.h' line='95' column='1'/>
            </data-member>
          </union-decl>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- tcmalloc::LogItem::Tag tcmalloc::LogItem::tag_ -->
          <var-decl name='tag_' type-id='type-id-1026' visibility='default' filepath='src/internal_logging.h' line='90' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- union {const char* str; void* ptr; int64_t snum; uint64_t unum;} tcmalloc::LogItem::u_ -->
          <var-decl name='u_' type-id='type-id-1027' visibility='default' filepath='src/internal_logging.h' line='96' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem() -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(const char*) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long int' -->
            <parameter type-id='type-id-80'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long long int' -->
            <parameter type-id='type-id-1029'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(unsigned int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'unsigned int' -->
            <parameter type-id='type-id-59'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(unsigned long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long long unsigned int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long long unsigned int' -->
            <parameter type-id='type-id-1030'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(void*) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- void (const char*, int) -->
    <function-type size-in-bits='64' id='type-id-1024'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- long long int -->
    <type-decl name='long long int' size-in-bits='64' id='type-id-1029'/>
    <!-- long long unsigned int -->
    <type-decl name='long long unsigned int' size-in-bits='64' id='type-id-1030'/>
    <!-- tcmalloc::LogItem* -->
    <pointer-type-def type-id='type-id-1019' size-in-bits='64' id='type-id-1028'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/malloc_extension.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- enum MallocExtension_Ownership -->
    <enum-decl name='MallocExtension_Ownership' filepath='src/gperftools/malloc_extension_c.h' line='87' column='1' id='type-id-1031'>
      <underlying-type type-id='type-id-84'/>
      <enumerator name='MallocExtension_kUnknownOwnership' value='0'/>
      <enumerator name='MallocExtension_kOwned' value='1'/>
      <enumerator name='MallocExtension_kNotOwned' value='2'/>
    </enum-decl>
    <!-- MallocExtension* -->
    <pointer-type-def type-id='type-id-803' size-in-bits='64' id='type-id-278'/>
    <!-- MallocExtension::RangeFunction* -->
    <pointer-type-def type-id='type-id-869' size-in-bits='64' id='type-id-873'/>
    <!-- MallocExtension_Ownership MallocExtension_GetOwnership(void*) -->
    <function-decl name='MallocExtension_GetOwnership' mangled-name='MallocExtension_GetOwnership' filepath='src/malloc_extension.cc' line='375' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_GetOwnership'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='p' filepath='src/malloc_extension.cc' line='375' column='1'/>
      <!-- enum MallocExtension_Ownership -->
      <return type-id='type-id-1031'/>
    </function-decl>
    <!-- size_t MallocExtension_GetAllocatedSize(void*) -->
    <function-decl name='MallocExtension_GetAllocatedSize' mangled-name='MallocExtension_GetAllocatedSize' filepath='src/malloc_extension.cc' line='371' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_GetAllocatedSize'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='ptr' filepath='src/tcmalloc.cc' line='1730' column='1'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- size_t MallocExtension_GetEstimatedAllocatedSize(size_t) -->
    <function-decl name='MallocExtension_GetEstimatedAllocatedSize' mangled-name='MallocExtension_GetEstimatedAllocatedSize' filepath='src/malloc_extension.cc' line='370' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_GetEstimatedAllocatedSize'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='size' filepath='src/malloc_extension.cc' line='370' column='1'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- void MallocExtension_ReleaseToSystem(size_t) -->
    <function-decl name='MallocExtension_ReleaseToSystem' mangled-name='MallocExtension_ReleaseToSystem' filepath='src/malloc_extension.cc' line='369' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_ReleaseToSystem'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='num_bytes' filepath='src/malloc_extension.cc' line='369' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void MallocExtension_ReleaseFreeMemory() -->
    <function-decl name='MallocExtension_ReleaseFreeMemory' mangled-name='MallocExtension_ReleaseFreeMemory' filepath='src/malloc_extension.cc' line='368' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_ReleaseFreeMemory'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void MallocExtension_MarkThreadBusy() -->
    <function-decl name='MallocExtension_MarkThreadBusy' mangled-name='MallocExtension_MarkThreadBusy' filepath='src/malloc_extension.cc' line='367' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_MarkThreadBusy'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void MallocExtension_MarkThreadIdle() -->
    <function-decl name='MallocExtension_MarkThreadIdle' mangled-name='MallocExtension_MarkThreadIdle' filepath='src/malloc_extension.cc' line='366' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_MarkThreadIdle'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int MallocExtension_SetNumericProperty(const char*, size_t) -->
    <function-decl name='MallocExtension_SetNumericProperty' mangled-name='MallocExtension_SetNumericProperty' filepath='src/malloc_extension.cc' line='364' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_SetNumericProperty'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocExtension_GetNumericProperty(const char*, size_t*) -->
    <function-decl name='MallocExtension_GetNumericProperty' mangled-name='MallocExtension_GetNumericProperty' filepath='src/malloc_extension.cc' line='362' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_GetNumericProperty'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='property' filepath='src/malloc_extension.cc' line='361' column='1'/>
      <!-- parameter of type 'size_t*' -->
      <parameter type-id='type-id-252' name='value' filepath='src/malloc_extension.cc' line='361' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void MallocExtension_GetStats(char*, int) -->
    <function-decl name='MallocExtension_GetStats' mangled-name='MallocExtension_GetStats' filepath='src/malloc_extension.cc' line='360' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_GetStats'>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113' name='buffer' filepath='src/malloc_extension.cc' line='359' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='buffer_length' filepath='src/malloc_extension.cc' line='359' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int MallocExtension_MallocMemoryStats(int*, size_t*, int*) -->
    <function-decl name='MallocExtension_MallocMemoryStats' mangled-name='MallocExtension_MallocMemoryStats' filepath='src/malloc_extension.cc' line='357' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_MallocMemoryStats'>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='blocks' filepath='src/malloc_extension.cc' line='355' column='1'/>
      <!-- parameter of type 'size_t*' -->
      <parameter type-id='type-id-252' name='total' filepath='src/malloc_extension.cc' line='355' column='1'/>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='histogram' filepath='src/malloc_extension.cc' line='355' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocExtension_VerifyMallocMemory(void*) -->
    <function-decl name='MallocExtension_VerifyMallocMemory' mangled-name='MallocExtension_VerifyMallocMemory' filepath='src/malloc_extension.cc' line='354' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_VerifyMallocMemory'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocExtension_VerifyArrayNewMemory(void*) -->
    <function-decl name='MallocExtension_VerifyArrayNewMemory' mangled-name='MallocExtension_VerifyArrayNewMemory' filepath='src/malloc_extension.cc' line='353' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_VerifyArrayNewMemory'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocExtension_VerifyNewMemory(void*) -->
    <function-decl name='MallocExtension_VerifyNewMemory' mangled-name='MallocExtension_VerifyNewMemory' filepath='src/malloc_extension.cc' line='352' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_VerifyNewMemory'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocExtension_VerifyAllMemory() -->
    <function-decl name='MallocExtension_VerifyAllMemory' mangled-name='MallocExtension_VerifyAllMemory' filepath='src/malloc_extension.cc' line='351' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocExtension_VerifyAllMemory'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/malloc_hook.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- typedef void (void*, typedef size_t, int, int, int, typedef off_t)* MallocHook_PreMmapHook -->
    <typedef-decl name='MallocHook_PreMmapHook' type-id='type-id-1032' filepath='./src/gperftools/malloc_hook_c.h' line='87' column='1' id='type-id-1033'/>
    <!-- typedef int (void*, typedef size_t, int, int, int, typedef off_t, void**)* MallocHook_MmapReplacement -->
    <typedef-decl name='MallocHook_MmapReplacement' type-id='type-id-1034' filepath='./src/gperftools/malloc_hook_c.h' line='111' column='1' id='type-id-1035'/>
    <!-- typedef int (void*, typedef size_t, int*)* MallocHook_MunmapReplacement -->
    <typedef-decl name='MallocHook_MunmapReplacement' type-id='type-id-1036' filepath='./src/gperftools/malloc_hook_c.h' line='123' column='1' id='type-id-1037'/>
    <!-- typedef void (void*, typedef size_t)* MallocHook_MunmapHook -->
    <typedef-decl name='MallocHook_MunmapHook' type-id='type-id-381' filepath='./src/gperftools/malloc_hook_c.h' line='115' column='1' id='type-id-1038'/>
    <!-- typedef void (void*, void*, typedef size_t, typedef size_t, int, void*)* MallocHook_MremapHook -->
    <typedef-decl name='MallocHook_MremapHook' type-id='type-id-1039' filepath='./src/gperftools/malloc_hook_c.h' line='132' column='1' id='type-id-1040'/>
    <!-- typedef void (typedef ptrdiff_t)* MallocHook_PreSbrkHook -->
    <typedef-decl name='MallocHook_PreSbrkHook' type-id='type-id-1041' filepath='./src/gperftools/malloc_hook_c.h' line='138' column='1' id='type-id-1042'/>
    <!-- base::internal::HookList<int (*)(const void*, size_t, int*)>* -->
    <pointer-type-def type-id='type-id-1043' size-in-bits='64' id='type-id-1044'/>
    <!-- base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>* -->
    <pointer-type-def type-id='type-id-1045' size-in-bits='64' id='type-id-1046'/>
    <!-- base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>* -->
    <pointer-type-def type-id='type-id-1047' size-in-bits='64' id='type-id-1048'/>
    <!-- base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>* -->
    <pointer-type-def type-id='type-id-1049' size-in-bits='64' id='type-id-1050'/>
    <!-- base::internal::HookList<void (*)(ptrdiff_t)>* -->
    <pointer-type-def type-id='type-id-1051' size-in-bits='64' id='type-id-1052'/>
    <!-- const base::internal::HookList<int (*)(const void*, size_t, int*)> -->
    <qualified-type-def type-id='type-id-1043' const='yes' id='type-id-1053'/>
    <!-- const base::internal::HookList<int (*)(const void*, size_t, int*)>* -->
    <pointer-type-def type-id='type-id-1053' size-in-bits='64' id='type-id-1054'/>
    <!-- const base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)> -->
    <qualified-type-def type-id='type-id-1045' const='yes' id='type-id-1055'/>
    <!-- const base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>* -->
    <pointer-type-def type-id='type-id-1055' size-in-bits='64' id='type-id-1056'/>
    <!-- const base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)> -->
    <qualified-type-def type-id='type-id-1047' const='yes' id='type-id-1057'/>
    <!-- const base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>* -->
    <pointer-type-def type-id='type-id-1057' size-in-bits='64' id='type-id-1058'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)> -->
    <qualified-type-def type-id='type-id-1049' const='yes' id='type-id-1059'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>* -->
    <pointer-type-def type-id='type-id-1059' size-in-bits='64' id='type-id-1060'/>
    <!-- const base::internal::HookList<void (*)(ptrdiff_t)> -->
    <qualified-type-def type-id='type-id-1051' const='yes' id='type-id-1061'/>
    <!-- const base::internal::HookList<void (*)(ptrdiff_t)>* -->
    <pointer-type-def type-id='type-id-1061' size-in-bits='64' id='type-id-1062'/>
    <!-- int (void*, typedef size_t, int*)* -->
    <pointer-type-def type-id='type-id-1063' size-in-bits='64' id='type-id-1036'/>
    <!-- int (void*, typedef size_t, int*)** -->
    <pointer-type-def type-id='type-id-1036' size-in-bits='64' id='type-id-1064'/>
    <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)* -->
    <pointer-type-def type-id='type-id-1065' size-in-bits='64' id='type-id-1034'/>
    <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)** -->
    <pointer-type-def type-id='type-id-1034' size-in-bits='64' id='type-id-1066'/>
    <!-- void (typedef ptrdiff_t)* -->
    <pointer-type-def type-id='type-id-1067' size-in-bits='64' id='type-id-1041'/>
    <!-- void (typedef ptrdiff_t)** -->
    <pointer-type-def type-id='type-id-1041' size-in-bits='64' id='type-id-1068'/>
    <!-- void (void*, typedef size_t, int, int, int, typedef off_t)* -->
    <pointer-type-def type-id='type-id-1069' size-in-bits='64' id='type-id-1032'/>
    <!-- void (void*, typedef size_t, int, int, int, typedef off_t)** -->
    <pointer-type-def type-id='type-id-1032' size-in-bits='64' id='type-id-1070'/>
    <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)* -->
    <pointer-type-def type-id='type-id-1071' size-in-bits='64' id='type-id-1039'/>
    <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)** -->
    <pointer-type-def type-id='type-id-1039' size-in-bits='64' id='type-id-1072'/>
    <!-- volatile base::subtle::Atomic64* -->
    <pointer-type-def type-id='type-id-1073' size-in-bits='64' id='type-id-1074'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- void** std::__copy_move_a<false, void**, void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_a&lt;false, void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::__copy_move_a2<false, void**, void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_a2&lt;false, void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::copy<void**, void**>(void**, void**, void**) -->
      <function-decl name='copy&lt;void**, void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- namespace base::internal -->
      <namespace-decl name='internal'>
        <!-- struct base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)> -->
        <class-decl name='HookList&lt;void (*)(const void*, size_t, int, int, int, off_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-1049'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::Add(void (void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvmiiilEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1050' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-1032'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvmiiilEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1050' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::Remove(void (void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvmiiilEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1050' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-1032'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::Traverse(void (void*, typedef size_t, int, int, int, typedef off_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvmiiilEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1060' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t, int, int, int, typedef off_t)**' -->
              <parameter type-id='type-id-1070'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvmiiilEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1060' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t, int, int, int, typedef off_t)* base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvmiiilEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1060' is-artificial='yes'/>
              <!-- void (void*, typedef size_t, int, int, int, typedef off_t)* -->
              <return type-id='type-id-1032'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t, int, int, int, typedef off_t)* base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>::ExchangeSingular(void (void*, typedef size_t, int, int, int, typedef off_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvmiiilEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)>*' -->
              <parameter type-id='type-id-1050' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t, int, int, int, typedef off_t)*' -->
              <parameter type-id='type-id-1032'/>
              <!-- void (void*, typedef size_t, int, int, int, typedef off_t)* -->
              <return type-id='type-id-1032'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)> -->
        <class-decl name='HookList&lt;void (*)(const void*, const void*, size_t, size_t, int, const void*)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-1047'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::Add(void (void*, void*, typedef size_t, typedef size_t, int, void*)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_mmiS3_EE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1048' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, typedef size_t, int, void*)*' -->
              <parameter type-id='type-id-1039'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_mmiS3_EE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1048' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::Remove(void (void*, void*, typedef size_t, typedef size_t, int, void*)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_mmiS3_EE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1048' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, typedef size_t, int, void*)*' -->
              <parameter type-id='type-id-1039'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::Traverse(void (void*, void*, typedef size_t, typedef size_t, int, void*)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_mmiS3_EE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1058' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, typedef size_t, int, void*)**' -->
              <parameter type-id='type-id-1072'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_mmiS3_EE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1058' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)* base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvS3_mmiS3_EE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1058' is-artificial='yes'/>
              <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)* -->
              <return type-id='type-id-1039'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)* base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>::ExchangeSingular(void (void*, void*, typedef size_t, typedef size_t, int, void*)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvS3_mmiS3_EE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)>*' -->
              <parameter type-id='type-id-1048' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, void*, typedef size_t, typedef size_t, int, void*)*' -->
              <parameter type-id='type-id-1039'/>
              <!-- void (void*, void*, typedef size_t, typedef size_t, int, void*)* -->
              <return type-id='type-id-1039'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<void (*)(ptrdiff_t)> -->
        <class-decl name='HookList&lt;void (*)(ptrdiff_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-1051'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(ptrdiff_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(ptrdiff_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(ptrdiff_t)>::Add(void (typedef ptrdiff_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvlEE3AddES3_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1052' is-artificial='yes'/>
              <!-- parameter of type 'void (typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-1041'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(ptrdiff_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvlEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1052' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(ptrdiff_t)>::Remove(void (typedef ptrdiff_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvlEE6RemoveES3_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1052' is-artificial='yes'/>
              <!-- parameter of type 'void (typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-1041'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(ptrdiff_t)>::Traverse(void (typedef ptrdiff_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvlEE8TraverseEPS3_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1062' is-artificial='yes'/>
              <!-- parameter of type 'void (typedef ptrdiff_t)**' -->
              <parameter type-id='type-id-1068'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(ptrdiff_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvlEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1062' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (typedef ptrdiff_t)* base::internal::HookList<void (*)(ptrdiff_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvlEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1062' is-artificial='yes'/>
              <!-- void (typedef ptrdiff_t)* -->
              <return type-id='type-id-1041'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (typedef ptrdiff_t)* base::internal::HookList<void (*)(ptrdiff_t)>::ExchangeSingular(void (typedef ptrdiff_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvlEE16ExchangeSingularES3_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(ptrdiff_t)>*' -->
              <parameter type-id='type-id-1052' is-artificial='yes'/>
              <!-- parameter of type 'void (typedef ptrdiff_t)*' -->
              <parameter type-id='type-id-1041'/>
              <!-- void (typedef ptrdiff_t)* -->
              <return type-id='type-id-1041'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)> -->
        <class-decl name='HookList&lt;int (*)(const void*, size_t, int, int, int, off_t, void**)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-1045'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::Add(int (void*, typedef size_t, int, int, int, typedef off_t, void**)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFiPKvmiiilPPvEE3AddES7_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1046' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int, int, int, typedef off_t, void**)*' -->
              <parameter type-id='type-id-1034'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFiPKvmiiilPPvEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1046' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::Remove(int (void*, typedef size_t, int, int, int, typedef off_t, void**)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFiPKvmiiilPPvEE6RemoveES7_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1046' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int, int, int, typedef off_t, void**)*' -->
              <parameter type-id='type-id-1034'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::Traverse(int (void*, typedef size_t, int, int, int, typedef off_t, void**)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFiPKvmiiilPPvEE8TraverseEPS7_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1056' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int, int, int, typedef off_t, void**)**' -->
              <parameter type-id='type-id-1066'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFiPKvmiiilPPvEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1056' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)* base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFiPKvmiiilPPvEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1056' is-artificial='yes'/>
              <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)* -->
              <return type-id='type-id-1034'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)* base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>::ExchangeSingular(int (void*, typedef size_t, int, int, int, typedef off_t, void**)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFiPKvmiiilPPvEE16ExchangeSingularES7_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)>*' -->
              <parameter type-id='type-id-1046' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int, int, int, typedef off_t, void**)*' -->
              <parameter type-id='type-id-1034'/>
              <!-- int (void*, typedef size_t, int, int, int, typedef off_t, void**)* -->
              <return type-id='type-id-1034'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<int (*)(const void*, size_t, int*)> -->
        <class-decl name='HookList&lt;int (*)(const void*, size_t, int*)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='src/malloc_hook-inl.h' line='59' column='1' id='type-id-1043'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<int (*)(const void*, size_t, int*)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<int (*)(const void*, size_t, int*)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int*)>::Add(int (void*, typedef size_t, int*)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFiPKvmPiEE3AddES6_' filepath='src/malloc_hook.cc' line='168' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1044' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int*)*' -->
              <parameter type-id='type-id-1036'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<int (*)(const void*, size_t, int*)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFiPKvmPiEE18FixupPrivEndLockedEv' filepath='src/malloc_hook.cc' line='192' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1044' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int*)>::Remove(int (void*, typedef size_t, int*)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFiPKvmPiEE6RemoveES6_' filepath='src/malloc_hook.cc' line='202' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1044' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int*)*' -->
              <parameter type-id='type-id-1036'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<int (*)(const void*, size_t, int*)>::Traverse(int (void*, typedef size_t, int*)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFiPKvmPiEE8TraverseEPS6_i' filepath='src/malloc_hook.cc' line='222' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1054' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int*)**' -->
              <parameter type-id='type-id-1064'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<int (*)(const void*, size_t, int*)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFiPKvmPiEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1054' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int (void*, typedef size_t, int*)* base::internal::HookList<int (*)(const void*, size_t, int*)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFiPKvmPiEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1054' is-artificial='yes'/>
              <!-- int (void*, typedef size_t, int*)* -->
              <return type-id='type-id-1036'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int (void*, typedef size_t, int*)* base::internal::HookList<int (*)(const void*, size_t, int*)>::ExchangeSingular(int (void*, typedef size_t, int*)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFiPKvmPiEE16ExchangeSingularES6_' filepath='src/malloc_hook.cc' line='237' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<int (*)(const void*, size_t, int*)>*' -->
              <parameter type-id='type-id-1044' is-artificial='yes'/>
              <!-- parameter of type 'int (void*, typedef size_t, int*)*' -->
              <parameter type-id='type-id-1036'/>
              <!-- int (void*, typedef size_t, int*)* -->
              <return type-id='type-id-1036'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- base::internal::HookList<void (*)(const void*, size_t)> base::internal::new_hooks_ -->
        <var-decl name='new_hooks_' type-id='type-id-1075' mangled-name='_ZN4base8internal10new_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='260' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*)> base::internal::delete_hooks_ -->
        <var-decl name='delete_hooks_' type-id='type-id-1076' mangled-name='_ZN4base8internal13delete_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='262' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*, size_t, int, int, int, off_t)> base::internal::premmap_hooks_ -->
        <var-decl name='premmap_hooks_' type-id='type-id-1049' mangled-name='_ZN4base8internal14premmap_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='263' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*, const void*, size_t, int, int, int, off_t)> base::internal::mmap_hooks_ -->
        <var-decl name='mmap_hooks_' type-id='type-id-421' mangled-name='_ZN4base8internal11mmap_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='265' column='1'/>
        <!-- base::internal::HookList<int (*)(const void*, size_t, int, int, int, off_t, void**)> base::internal::mmap_replacement_ -->
        <var-decl name='mmap_replacement_' type-id='type-id-1045' mangled-name='_ZN4base8internal17mmap_replacement_E' visibility='default' filepath='src/malloc_hook.cc' line='273' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*, size_t)> base::internal::munmap_hooks_ -->
        <var-decl name='munmap_hooks_' type-id='type-id-1075' mangled-name='_ZN4base8internal13munmap_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='266' column='1'/>
        <!-- base::internal::HookList<int (*)(const void*, size_t, int*)> base::internal::munmap_replacement_ -->
        <var-decl name='munmap_replacement_' type-id='type-id-1043' mangled-name='_ZN4base8internal19munmap_replacement_E' visibility='default' filepath='src/malloc_hook.cc' line='274' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*, const void*, size_t, size_t, int, const void*)> base::internal::mremap_hooks_ -->
        <var-decl name='mremap_hooks_' type-id='type-id-1047' mangled-name='_ZN4base8internal13mremap_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='267' column='1'/>
        <!-- base::internal::HookList<void (*)(ptrdiff_t)> base::internal::presbrk_hooks_ -->
        <var-decl name='presbrk_hooks_' type-id='type-id-1051' mangled-name='_ZN4base8internal14presbrk_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='268' column='1'/>
        <!-- base::internal::HookList<void (*)(const void*, ptrdiff_t)> base::internal::sbrk_hooks_ -->
        <var-decl name='sbrk_hooks_' type-id='type-id-423' mangled-name='_ZN4base8internal11sbrk_hooks_E' visibility='default' filepath='src/malloc_hook.cc' line='270' column='1'/>
      </namespace-decl>
      <!-- namespace base::subtle -->
      <namespace-decl name='subtle'>
        <!-- void base::subtle::NoBarrier_Store(volatile base::subtle::Atomic64*, base::subtle::Atomic64) -->
        <function-decl name='NoBarrier_Store' filepath='./src/base/atomicops-internals-x86.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'volatile base::subtle::Atomic64*' -->
          <parameter type-id='type-id-1074'/>
          <!-- parameter of type 'typedef base::subtle::Atomic64' -->
          <parameter type-id='type-id-1077'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
        <!-- base::subtle::Atomic64 base::subtle::Acquire_Load(const volatile base::subtle::Atomic64*) -->
        <function-decl name='Acquire_Load' filepath='./src/base/atomicops-internals-x86.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const volatile base::subtle::Atomic64*' -->
          <parameter type-id='type-id-1078'/>
          <!-- typedef base::subtle::Atomic64 -->
          <return type-id='type-id-1077'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- void* mmap(void*, size_t, int, int, int, off_t) -->
    <function-decl name='mmap' mangled-name='mmap' filepath='src/malloc_hook_mmap_linux.h' line='169' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mmap'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='start' filepath='src/malloc_hook_mmap_linux.h' line='169' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='length' filepath='src/malloc_hook_mmap_linux.h' line='169' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='prot' filepath='src/malloc_hook_mmap_linux.h' line='169' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='flags' filepath='src/malloc_hook_mmap_linux.h' line='169' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='fd' filepath='src/malloc_hook_mmap_linux.h' line='170' column='1'/>
      <!-- parameter of type 'typedef off_t' -->
      <parameter type-id='type-id-207' name='offset' filepath='src/malloc_hook_mmap_linux.h' line='170' column='1'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* mmap64(void*, size_t, int, int, int, __off64_t) -->
    <function-decl name='mmap64' mangled-name='mmap64' filepath='src/malloc_hook_mmap_linux.h' line='155' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mmap64'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='start' filepath='src/malloc_hook_mmap_linux.h' line='155' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='length' filepath='src/malloc_hook_mmap_linux.h' line='155' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='prot' filepath='src/malloc_hook_mmap_linux.h' line='155' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='flags' filepath='src/malloc_hook_mmap_linux.h' line='155' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='fd' filepath='src/malloc_hook_mmap_linux.h' line='156' column='1'/>
      <!-- parameter of type 'typedef __off64_t' -->
      <parameter type-id='type-id-1079' name='offset' filepath='src/malloc_hook_mmap_linux.h' line='156' column='1'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- int munmap(void*, size_t) -->
    <function-decl name='munmap' mangled-name='munmap' filepath='src/malloc_hook_mmap_linux.h' line='184' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='munmap'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='start' filepath='src/malloc_hook_mmap_linux.h' line='184' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='length' filepath='src/malloc_hook_mmap_linux.h' line='184' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void* sbrk(ptrdiff_t) -->
    <function-decl name='sbrk' mangled-name='sbrk' filepath='src/malloc_hook_mmap_linux.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sbrk'>
      <!-- parameter of type 'typedef ptrdiff_t' -->
      <parameter type-id='type-id-208' name='increment' filepath='src/malloc_hook_mmap_linux.h' line='209' column='1'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* mremap(void*, size_t, size_t, int, ...) -->
    <function-decl name='mremap' mangled-name='mremap' filepath='src/malloc_hook_mmap_linux.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mremap'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='old_addr' filepath='src/malloc_hook_mmap_linux.h' line='193' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='old_size' filepath='src/malloc_hook_mmap_linux.h' line='193' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='new_size' filepath='src/malloc_hook_mmap_linux.h' line='193' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='flags' filepath='src/malloc_hook_mmap_linux.h' line='194' column='1'/>
      <parameter is-variadic='yes'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- int MallocHook_GetCallerStackTrace(void**, int, int) -->
    <function-decl name='MallocHook_GetCallerStackTrace' mangled-name='MallocHook_GetCallerStackTrace' filepath='src/malloc_hook.cc' line='611' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_GetCallerStackTrace'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result' filepath='src/malloc_hook.cc' line='611' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='max_depth' filepath='src/malloc_hook.cc' line='611' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='skip_count' filepath='src/malloc_hook.cc' line='612' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddPreSbrkHook(MallocHook_PreSbrkHook) -->
    <function-decl name='MallocHook_AddPreSbrkHook' mangled-name='MallocHook_AddPreSbrkHook' filepath='src/malloc_hook.cc' line='399' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddPreSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_PreSbrkHook' -->
      <parameter type-id='type-id-1042' name='hook' filepath='src/malloc_hook.cc' line='399' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- MallocHook_MunmapHook MallocHook_SetMunmapHook(MallocHook_MunmapHook) -->
    <function-decl name='MallocHook_SetMunmapHook' mangled-name='MallocHook_SetMunmapHook' filepath='src/malloc_hook.cc' line='448' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetMunmapHook'>
      <!-- parameter of type 'typedef MallocHook_MunmapHook' -->
      <parameter type-id='type-id-1038' name='hook' filepath='src/malloc_hook.cc' line='448' column='1'/>
      <!-- typedef MallocHook_MunmapHook -->
      <return type-id='type-id-1038'/>
    </function-decl>
    <!-- MallocHook_NewHook MallocHook_SetNewHook(MallocHook_NewHook) -->
    <function-decl name='MallocHook_SetNewHook' mangled-name='MallocHook_SetNewHook' filepath='src/malloc_hook.cc' line='424' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetNewHook'>
      <!-- parameter of type 'typedef MallocHook_NewHook' -->
      <parameter type-id='type-id-382' name='hook' filepath='src/malloc_hook.cc' line='424' column='1'/>
      <!-- typedef MallocHook_NewHook -->
      <return type-id='type-id-382'/>
    </function-decl>
    <!-- MallocHook_SbrkHook MallocHook_SetSbrkHook(MallocHook_SbrkHook) -->
    <function-decl name='MallocHook_SetSbrkHook' mangled-name='MallocHook_SetSbrkHook' filepath='src/malloc_hook.cc' line='466' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_SbrkHook' -->
      <parameter type-id='type-id-387' name='hook' filepath='src/malloc_hook.cc' line='466' column='1'/>
      <!-- typedef MallocHook_SbrkHook -->
      <return type-id='type-id-387'/>
    </function-decl>
    <!-- MallocHook_PreSbrkHook MallocHook_SetPreSbrkHook(MallocHook_PreSbrkHook) -->
    <function-decl name='MallocHook_SetPreSbrkHook' mangled-name='MallocHook_SetPreSbrkHook' filepath='src/malloc_hook.cc' line='460' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetPreSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_PreSbrkHook' -->
      <parameter type-id='type-id-1042' name='hook' filepath='src/malloc_hook.cc' line='460' column='1'/>
      <!-- typedef MallocHook_PreSbrkHook -->
      <return type-id='type-id-1042'/>
    </function-decl>
    <!-- MallocHook_MremapHook MallocHook_SetMremapHook(MallocHook_MremapHook) -->
    <function-decl name='MallocHook_SetMremapHook' mangled-name='MallocHook_SetMremapHook' filepath='src/malloc_hook.cc' line='454' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetMremapHook'>
      <!-- parameter of type 'typedef MallocHook_MremapHook' -->
      <parameter type-id='type-id-1040' name='hook' filepath='src/malloc_hook.cc' line='454' column='1'/>
      <!-- typedef MallocHook_MremapHook -->
      <return type-id='type-id-1040'/>
    </function-decl>
    <!-- MallocHook_MmapHook MallocHook_SetMmapHook(MallocHook_MmapHook) -->
    <function-decl name='MallocHook_SetMmapHook' mangled-name='MallocHook_SetMmapHook' filepath='src/malloc_hook.cc' line='442' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetMmapHook'>
      <!-- parameter of type 'typedef MallocHook_MmapHook' -->
      <parameter type-id='type-id-385' name='hook' filepath='src/malloc_hook.cc' line='442' column='1'/>
      <!-- typedef MallocHook_MmapHook -->
      <return type-id='type-id-385'/>
    </function-decl>
    <!-- MallocHook_PreMmapHook MallocHook_SetPreMmapHook(MallocHook_PreMmapHook) -->
    <function-decl name='MallocHook_SetPreMmapHook' mangled-name='MallocHook_SetPreMmapHook' filepath='src/malloc_hook.cc' line='436' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetPreMmapHook'>
      <!-- parameter of type 'typedef MallocHook_PreMmapHook' -->
      <parameter type-id='type-id-1033' name='hook' filepath='src/malloc_hook.cc' line='436' column='1'/>
      <!-- typedef MallocHook_PreMmapHook -->
      <return type-id='type-id-1033'/>
    </function-decl>
    <!-- MallocHook_DeleteHook MallocHook_SetDeleteHook(MallocHook_DeleteHook) -->
    <function-decl name='MallocHook_SetDeleteHook' mangled-name='MallocHook_SetDeleteHook' filepath='src/malloc_hook.cc' line='430' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetDeleteHook'>
      <!-- parameter of type 'typedef MallocHook_DeleteHook' -->
      <parameter type-id='type-id-383' name='hook' filepath='src/malloc_hook.cc' line='430' column='1'/>
      <!-- typedef MallocHook_DeleteHook -->
      <return type-id='type-id-383'/>
    </function-decl>
    <!-- int MallocHook_RemoveMunmapHook(MallocHook_MunmapHook) -->
    <function-decl name='MallocHook_RemoveMunmapHook' mangled-name='MallocHook_RemoveMunmapHook' filepath='src/malloc_hook.cc' line='365' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveMunmapHook'>
      <!-- parameter of type 'typedef MallocHook_MunmapHook' -->
      <parameter type-id='type-id-1038' name='hook' filepath='src/malloc_hook.cc' line='365' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveNewHook(MallocHook_NewHook) -->
    <function-decl name='MallocHook_RemoveNewHook' mangled-name='MallocHook_RemoveNewHook' filepath='src/malloc_hook.cc' line='302' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveNewHook'>
      <!-- parameter of type 'typedef MallocHook_NewHook' -->
      <parameter type-id='type-id-382' name='hook' filepath='src/malloc_hook.cc' line='302' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveSbrkHook(MallocHook_SbrkHook) -->
    <function-decl name='MallocHook_RemoveSbrkHook' mangled-name='MallocHook_RemoveSbrkHook' filepath='src/malloc_hook.cc' line='417' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_SbrkHook' -->
      <parameter type-id='type-id-387' name='hook' filepath='src/malloc_hook.cc' line='417' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveMmapReplacement(MallocHook_MmapReplacement) -->
    <function-decl name='MallocHook_RemoveMmapReplacement' mangled-name='MallocHook_RemoveMmapReplacement' filepath='src/malloc_hook.cc' line='341' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveMmapReplacement'>
      <!-- parameter of type 'typedef MallocHook_MmapReplacement' -->
      <parameter type-id='type-id-1035' name='hook' filepath='src/malloc_hook.cc' line='341' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemovePreMmapHook(MallocHook_PreMmapHook) -->
    <function-decl name='MallocHook_RemovePreMmapHook' mangled-name='MallocHook_RemovePreMmapHook' filepath='src/malloc_hook.cc' line='326' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemovePreMmapHook'>
      <!-- parameter of type 'typedef MallocHook_PreMmapHook' -->
      <parameter type-id='type-id-1033' name='hook' filepath='src/malloc_hook.cc' line='326' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveDeleteHook(MallocHook_DeleteHook) -->
    <function-decl name='MallocHook_RemoveDeleteHook' mangled-name='MallocHook_RemoveDeleteHook' filepath='src/malloc_hook.cc' line='314' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveDeleteHook'>
      <!-- parameter of type 'typedef MallocHook_DeleteHook' -->
      <parameter type-id='type-id-383' name='hook' filepath='src/malloc_hook.cc' line='314' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemovePreSbrkHook(MallocHook_PreSbrkHook) -->
    <function-decl name='MallocHook_RemovePreSbrkHook' mangled-name='MallocHook_RemovePreSbrkHook' filepath='src/malloc_hook.cc' line='405' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemovePreSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_PreSbrkHook' -->
      <parameter type-id='type-id-1042' name='hook' filepath='src/malloc_hook.cc' line='399' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveMremapHook(MallocHook_MremapHook) -->
    <function-decl name='MallocHook_RemoveMremapHook' mangled-name='MallocHook_RemoveMremapHook' filepath='src/malloc_hook.cc' line='393' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveMremapHook'>
      <!-- parameter of type 'typedef MallocHook_MremapHook' -->
      <parameter type-id='type-id-1040' name='hook' filepath='src/malloc_hook.cc' line='393' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveMunmapReplacement(MallocHook_MunmapReplacement) -->
    <function-decl name='MallocHook_RemoveMunmapReplacement' mangled-name='MallocHook_RemoveMunmapReplacement' filepath='src/malloc_hook.cc' line='381' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveMunmapReplacement'>
      <!-- parameter of type 'typedef MallocHook_MunmapReplacement' -->
      <parameter type-id='type-id-1037' name='hook' filepath='src/malloc_hook.cc' line='381' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_RemoveMmapHook(MallocHook_MmapHook) -->
    <function-decl name='MallocHook_RemoveMmapHook' mangled-name='MallocHook_RemoveMmapHook' filepath='src/malloc_hook.cc' line='353' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_RemoveMmapHook'>
      <!-- parameter of type 'typedef MallocHook_MmapHook' -->
      <parameter type-id='type-id-385' name='hook' filepath='src/malloc_hook.cc' line='353' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddMmapHook(MallocHook_MmapHook) -->
    <function-decl name='MallocHook_AddMmapHook' mangled-name='MallocHook_AddMmapHook' filepath='src/malloc_hook.cc' line='347' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddMmapHook'>
      <!-- parameter of type 'typedef MallocHook_MmapHook' -->
      <parameter type-id='type-id-385' name='hook' filepath='src/malloc_hook.cc' line='353' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddMremapHook(MallocHook_MremapHook) -->
    <function-decl name='MallocHook_AddMremapHook' mangled-name='MallocHook_AddMremapHook' filepath='src/malloc_hook.cc' line='387' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddMremapHook'>
      <!-- parameter of type 'typedef MallocHook_MremapHook' -->
      <parameter type-id='type-id-1040' name='hook' filepath='src/malloc_hook.cc' line='393' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_SetMunmapReplacement(MallocHook_MunmapReplacement) -->
    <function-decl name='MallocHook_SetMunmapReplacement' mangled-name='MallocHook_SetMunmapReplacement' filepath='src/malloc_hook.cc' line='371' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetMunmapReplacement'>
      <!-- parameter of type 'typedef MallocHook_MunmapReplacement' -->
      <parameter type-id='type-id-1037' name='hook' filepath='src/malloc_hook.cc' line='381' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_SetMmapReplacement(MallocHook_MmapReplacement) -->
    <function-decl name='MallocHook_SetMmapReplacement' mangled-name='MallocHook_SetMmapReplacement' filepath='src/malloc_hook.cc' line='332' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_SetMmapReplacement'>
      <!-- parameter of type 'typedef MallocHook_MmapReplacement' -->
      <parameter type-id='type-id-1035' name='hook' filepath='src/malloc_hook.cc' line='341' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddPreMmapHook(MallocHook_PreMmapHook) -->
    <function-decl name='MallocHook_AddPreMmapHook' mangled-name='MallocHook_AddPreMmapHook' filepath='src/malloc_hook.cc' line='320' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddPreMmapHook'>
      <!-- parameter of type 'typedef MallocHook_PreMmapHook' -->
      <parameter type-id='type-id-1033' name='hook' filepath='src/malloc_hook.cc' line='326' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddMunmapHook(MallocHook_MunmapHook) -->
    <function-decl name='MallocHook_AddMunmapHook' mangled-name='MallocHook_AddMunmapHook' filepath='src/malloc_hook.cc' line='359' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddMunmapHook'>
      <!-- parameter of type 'typedef MallocHook_MunmapHook' -->
      <parameter type-id='type-id-1038' name='hook' filepath='src/malloc_hook.cc' line='365' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddNewHook(MallocHook_NewHook) -->
    <function-decl name='MallocHook_AddNewHook' mangled-name='MallocHook_AddNewHook' filepath='src/malloc_hook.cc' line='296' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddNewHook'>
      <!-- parameter of type 'typedef MallocHook_NewHook' -->
      <parameter type-id='type-id-382' name='hook' filepath='src/malloc_hook.cc' line='302' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddSbrkHook(MallocHook_SbrkHook) -->
    <function-decl name='MallocHook_AddSbrkHook' mangled-name='MallocHook_AddSbrkHook' filepath='src/malloc_hook.cc' line='411' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddSbrkHook'>
      <!-- parameter of type 'typedef MallocHook_SbrkHook' -->
      <parameter type-id='type-id-387' name='hook' filepath='src/malloc_hook.cc' line='417' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int MallocHook_AddDeleteHook(MallocHook_DeleteHook) -->
    <function-decl name='MallocHook_AddDeleteHook' mangled-name='MallocHook_AddDeleteHook' filepath='src/malloc_hook.cc' line='308' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='MallocHook_AddDeleteHook'>
      <!-- parameter of type 'typedef MallocHook_DeleteHook' -->
      <parameter type-id='type-id-383' name='hook' filepath='src/malloc_hook.cc' line='314' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- const volatile base::subtle::Atomic64* -->
    <pointer-type-def type-id='type-id-1080' size-in-bits='64' id='type-id-1078'/>
    <!-- int (void*, size_t, int*) -->
    <function-type size-in-bits='64' id='type-id-1063'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-type>
    <!-- int (void*, size_t, int, int, int, off_t, void**) -->
    <function-type size-in-bits='64' id='type-id-1065'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'typedef off_t' -->
      <parameter type-id='type-id-207'/>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-type>
    <!-- void (ptrdiff_t) -->
    <function-type size-in-bits='64' id='type-id-1067'>
      <!-- parameter of type 'typedef ptrdiff_t' -->
      <parameter type-id='type-id-208'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, size_t, int, int, int, off_t) -->
    <function-type size-in-bits='64' id='type-id-1069'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'typedef off_t' -->
      <parameter type-id='type-id-207'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, void*, size_t, size_t, int, void*) -->
    <function-type size-in-bits='64' id='type-id-1071'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <namespace-decl name='base'>
      <namespace-decl name='internal'>
        <!-- struct base::internal::HookList<void (*)(const void*)> -->
        <class-decl name='HookList&lt;void (*)(const void*)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='./src/malloc_hook-inl.h' line='59' column='1' id='type-id-1076'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::Add(void (void*)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::Remove(void (void*)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*)>::Traverse(void (void*)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)**' -->
              <parameter type-id='type-id-1083'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*)* base::internal::HookList<void (*)(const void*)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- void (void*)* -->
              <return type-id='type-id-240'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*)* base::internal::HookList<void (*)(const void*)>::ExchangeSingular(void (void*)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- void (void*)* -->
              <return type-id='type-id-240'/>
            </function-decl>
          </member-function>
        </class-decl>
      </namespace-decl>
    </namespace-decl>
    <namespace-decl name='base'>
      <namespace-decl name='internal'>
        <!-- struct base::internal::HookList<void (*)(const void*, size_t)> -->
        <class-decl name='HookList&lt;void (*)(const void*, size_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='./src/malloc_hook-inl.h' line='59' column='1' id='type-id-1075'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::Add(void (void*, typedef size_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE3AddES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, size_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE18FixupPrivEndLockedEv'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::Remove(void (void*, typedef size_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE6RemoveES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, size_t)>::Traverse(void (void*, typedef size_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE8TraverseEPS5_i'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)**' -->
              <parameter type-id='type-id-1086'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE5emptyEv'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t)* base::internal::HookList<void (*)(const void*, size_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE11GetSingularEv'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- void (void*, typedef size_t)* -->
              <return type-id='type-id-381'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t)* base::internal::HookList<void (*)(const void*, size_t)>::ExchangeSingular(void (void*, typedef size_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE16ExchangeSingularES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- void (void*, typedef size_t)* -->
              <return type-id='type-id-381'/>
            </function-decl>
          </member-function>
        </class-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- typedef long int __off64_t -->
    <typedef-decl name='__off64_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='142' column='1' id='type-id-1079'/>
    <namespace-decl name='base'>
      <namespace-decl name='subtle'>
        <!-- typedef int64_t base::subtle::Atomic64 -->
        <typedef-decl name='Atomic64' type-id='type-id-98' filepath='./src/base/atomicops-internals-x86.h' line='70' column='1' id='type-id-1077'/>
      </namespace-decl>
    </namespace-decl>
    <!-- volatile base::subtle::Atomic64 -->
    <qualified-type-def type-id='type-id-1077' volatile='yes' id='type-id-1073'/>
    <!-- base::internal::HookList<void (*)(const void*)>* -->
    <pointer-type-def type-id='type-id-1076' size-in-bits='64' id='type-id-1081'/>
    <!-- base::internal::HookList<void (*)(const void*, size_t)>* -->
    <pointer-type-def type-id='type-id-1075' size-in-bits='64' id='type-id-1084'/>
    <!-- const base::internal::HookList<void (*)(const void*)>* -->
    <pointer-type-def type-id='type-id-1087' size-in-bits='64' id='type-id-1082'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t)>* -->
    <pointer-type-def type-id='type-id-1088' size-in-bits='64' id='type-id-1085'/>
    <!-- const volatile base::subtle::Atomic64 -->
    <qualified-type-def type-id='type-id-1073' const='yes' id='type-id-1080'/>
    <!-- void (void*)** -->
    <pointer-type-def type-id='type-id-240' size-in-bits='64' id='type-id-1083'/>
    <!-- void (void*, typedef size_t)** -->
    <pointer-type-def type-id='type-id-381' size-in-bits='64' id='type-id-1086'/>
    <!-- const base::internal::HookList<void (*)(const void*)> -->
    <qualified-type-def type-id='type-id-1076' const='yes' id='type-id-1087'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t)> -->
    <qualified-type-def type-id='type-id-1075' const='yes' id='type-id-1088'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/maybe_threads.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- pthread_key_t* -->
    <pointer-type-def type-id='type-id-1089' size-in-bits='64' id='type-id-1090'/>
    <!-- pthread_once_t* -->
    <pointer-type-def type-id='type-id-1091' size-in-bits='64' id='type-id-1092'/>
    <!-- int perftools_pthread_once(pthread_once_t*, void ()*) -->
    <function-decl name='perftools_pthread_once' mangled-name='_Z22perftools_pthread_oncePiPFvvE' filepath='src/maybe_threads.cc' line='128' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z22perftools_pthread_oncePiPFvvE'>
      <!-- parameter of type 'pthread_once_t*' -->
      <parameter type-id='type-id-1092' name='ctl' filepath='src/maybe_threads.cc' line='128' column='1'/>
      <!-- parameter of type 'void ()*' -->
      <parameter type-id='type-id-176' name='init_routine' filepath='src/maybe_threads.cc' line='129' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int perftools_pthread_setspecific(pthread_key_t, void*) -->
    <function-decl name='perftools_pthread_setspecific' mangled-name='_Z29perftools_pthread_setspecificjPv' filepath='src/maybe_threads.cc' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z29perftools_pthread_setspecificjPv'>
      <!-- parameter of type 'typedef pthread_key_t' -->
      <parameter type-id='type-id-1089' name='key' filepath='src/maybe_threads.cc' line='117' column='1'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='val' filepath='src/maybe_threads.cc' line='117' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void* perftools_pthread_getspecific(pthread_key_t) -->
    <function-decl name='perftools_pthread_getspecific' mangled-name='_Z29perftools_pthread_getspecificj' filepath='src/maybe_threads.cc' line='109' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z29perftools_pthread_getspecificj'>
      <!-- parameter of type 'typedef pthread_key_t' -->
      <parameter type-id='type-id-1089' name='key' filepath='src/maybe_threads.cc' line='109' column='1'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- int perftools_pthread_key_delete(pthread_key_t) -->
    <function-decl name='perftools_pthread_key_delete' mangled-name='_Z28perftools_pthread_key_deletej' filepath='src/maybe_threads.cc' line='101' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z28perftools_pthread_key_deletej'>
      <!-- parameter of type 'typedef pthread_key_t' -->
      <parameter type-id='type-id-1089' name='key' filepath='src/maybe_threads.cc' line='101' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int perftools_pthread_key_create(pthread_key_t*, void (void*)*) -->
    <function-decl name='perftools_pthread_key_create' mangled-name='_Z28perftools_pthread_key_createPjPFvPvE' filepath='src/maybe_threads.cc' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z28perftools_pthread_key_createPjPFvPvE'>
      <!-- parameter of type 'pthread_key_t*' -->
      <parameter type-id='type-id-1090' name='key' filepath='src/maybe_threads.cc' line='90' column='1'/>
      <!-- parameter of type 'void (void*)*' -->
      <parameter type-id='type-id-240' name='destr_function' filepath='src/maybe_threads.cc' line='91' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- typedef unsigned int pthread_key_t -->
    <typedef-decl name='pthread_key_t' type-id='type-id-59' filepath='/usr/include/bits/pthreadtypes.h' line='140' column='1' id='type-id-1089'/>
    <!-- typedef int pthread_once_t -->
    <typedef-decl name='pthread_once_t' type-id='type-id-1' filepath='/usr/include/bits/pthreadtypes.h' line='144' column='1' id='type-id-1091'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/memfs_malloc.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- class HugetlbSysAllocator -->
    <class-decl name='HugetlbSysAllocator' size-in-bits='384' visibility='default' filepath='src/memfs_malloc.cc' line='90' column='1' id='type-id-1093'>
      <!-- class SysAllocator -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-929'/>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- bool HugetlbSysAllocator::failed_ -->
        <var-decl name='failed_' type-id='type-id-55' visibility='default' filepath='src/memfs_malloc.cc' line='103' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- int64 HugetlbSysAllocator::big_page_size_ -->
        <var-decl name='big_page_size_' type-id='type-id-93' visibility='default' filepath='src/memfs_malloc.cc' line='108' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- int HugetlbSysAllocator::hugetlb_fd_ -->
        <var-decl name='hugetlb_fd_' type-id='type-id-1' visibility='default' filepath='src/memfs_malloc.cc' line='109' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- off_t HugetlbSysAllocator::hugetlb_base_ -->
        <var-decl name='hugetlb_base_' type-id='type-id-207' visibility='default' filepath='src/memfs_malloc.cc' line='110' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='320'>
        <!-- SysAllocator* HugetlbSysAllocator::fallback_ -->
        <var-decl name='fallback_' type-id='type-id-874' visibility='default' filepath='src/memfs_malloc.cc' line='112' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- HugetlbSysAllocator::HugetlbSysAllocator(SysAllocator*) -->
        <function-decl name='HugetlbSysAllocator' filepath='src/memfs_malloc.cc' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'HugetlbSysAllocator*' -->
          <parameter type-id='type-id-1094' is-artificial='yes'/>
          <!-- parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool HugetlbSysAllocator::Initialize() -->
        <function-decl name='Initialize' mangled-name='_ZN19HugetlbSysAllocator10InitializeEv' filepath='src/memfs_malloc.cc' line='218' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN19HugetlbSysAllocator10InitializeEv'>
          <!-- implicit parameter of type 'HugetlbSysAllocator*' -->
          <parameter type-id='type-id-1094' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void* HugetlbSysAllocator::AllocInternal(size_t, size_t*, size_t) -->
        <function-decl name='AllocInternal' mangled-name='_ZN19HugetlbSysAllocator13AllocInternalEmPmm' filepath='src/memfs_malloc.cc' line='152' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN19HugetlbSysAllocator13AllocInternalEmPmm'>
          <!-- implicit parameter of type 'HugetlbSysAllocator*' -->
          <parameter type-id='type-id-1094' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* HugetlbSysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN19HugetlbSysAllocator5AllocEmPmm' filepath='src/memfs_malloc.cc' line='118' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN19HugetlbSysAllocator5AllocEmPmm'>
          <!-- implicit parameter of type 'HugetlbSysAllocator*' -->
          <parameter type-id='type-id-1094' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- HugetlbSysAllocator* -->
    <pointer-type-def type-id='type-id-1093' size-in-bits='64' id='type-id-1094'/>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead'>
      <!-- std::string FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_memfs_malloc_path -->
      <var-decl name='FLAGS_memfs_malloc_path' type-id='type-id-800' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_memfs_malloc_pathE' visibility='default' filepath='src/memfs_malloc.cc' line='70' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_memfs_malloc_pathE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_nomemfs_malloc_path -->
      <var-decl name='FLAGS_nomemfs_malloc_path' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead25FLAGS_nomemfs_malloc_pathE' visibility='default' filepath='src/memfs_malloc.cc' line='73' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead25FLAGS_nomemfs_malloc_pathE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_memfs_malloc_limit_mb -->
      <var-decl name='FLAGS_memfs_malloc_limit_mb' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead27FLAGS_memfs_malloc_limit_mbE' visibility='default' filepath='src/memfs_malloc.cc' line='74' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead27FLAGS_memfs_malloc_limit_mbE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_nomemfs_malloc_limit_mb -->
      <var-decl name='FLAGS_nomemfs_malloc_limit_mb' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead29FLAGS_nomemfs_malloc_limit_mbE' visibility='default' filepath='src/memfs_malloc.cc' line='77' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead29FLAGS_nomemfs_malloc_limit_mbE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_abort_on_fail -->
      <var-decl name='FLAGS_memfs_malloc_abort_on_fail' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_memfs_malloc_abort_on_failE' visibility='default' filepath='src/memfs_malloc.cc' line='78' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_memfs_malloc_abort_on_failE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_abort_on_fail -->
      <var-decl name='FLAGS_nomemfs_malloc_abort_on_fail' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_nomemfs_malloc_abort_on_failE' visibility='default' filepath='src/memfs_malloc.cc' line='81' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead34FLAGS_nomemfs_malloc_abort_on_failE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_ignore_mmap_fail -->
      <var-decl name='FLAGS_memfs_malloc_ignore_mmap_fail' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_memfs_malloc_ignore_mmap_failE' visibility='default' filepath='src/memfs_malloc.cc' line='82' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_memfs_malloc_ignore_mmap_failE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_ignore_mmap_fail -->
      <var-decl name='FLAGS_nomemfs_malloc_ignore_mmap_fail' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomemfs_malloc_ignore_mmap_failE' visibility='default' filepath='src/memfs_malloc.cc' line='84' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomemfs_malloc_ignore_mmap_failE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_memfs_malloc_map_private -->
      <var-decl name='FLAGS_memfs_malloc_map_private' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_memfs_malloc_map_privateE' visibility='default' filepath='src/memfs_malloc.cc' line='85' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead30FLAGS_memfs_malloc_map_privateE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomemfs_malloc_map_private -->
      <var-decl name='FLAGS_nomemfs_malloc_map_private' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_nomemfs_malloc_map_privateE' visibility='default' filepath='src/memfs_malloc.cc' line='87' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead32FLAGS_nomemfs_malloc_map_privateE'/>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/memory_region_map.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- HeapProfileBucket[20] -->
    <array-type-def dimensions='1' type-id='type-id-212' size-in-bits='8960' id='type-id-201'>
      <!-- <anonymous range>[20] -->
      <subrange length='20' type-id='type-id-5' id='type-id-802'/>
    </array-type-def>
    <!-- void*[20][32] -->
    <array-type-def dimensions='2' type-id='type-id-53' size-in-bits='40960' id='type-id-202'>
      <!-- <anonymous range>[20] -->
      <subrange length='20' type-id='type-id-5' id='type-id-802'/>
      <!-- <anonymous range>[32] -->
      <subrange length='32' type-id='type-id-5' id='type-id-153'/>
    </array-type-def>
    <!-- class STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
    <class-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;MemoryRegionMap::Region&gt;, MemoryRegionMap::MyAllocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-892'>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::STL_Allocator(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::address(std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7addressERS3_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-932'/>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-742'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::address(const std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7addressERKS3_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-933'/>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-540'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
          <return type-id='type-id-742'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::deallocate(std::_Rb_tree_node<MemoryRegionMap::Region>*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE10deallocateEPS3_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::construct(std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE9constructEPS3_RKS3_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>&' -->
          <parameter type-id='type-id-933'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::construct(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE9constructEPS3_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::destroy(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEE7destroyEPS3_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-930' is-artificial='yes'/>
          <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
          <parameter type-id='type-id-742'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>::operator==(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorISt13_Rb_tree_nodeIN15MemoryRegionMap6RegionEENS1_11MyAllocatorEEeqERKS5_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-931' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
    <class-decl name='STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt;' size-in-bits='8' visibility='default' filepath='src/base/stl_allocator.h' line='60' column='1' id='type-id-832'>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator() -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator(const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator' filepath='src/base/stl_allocator.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-828'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::~STL_Allocator(int) -->
        <function-decl name='~STL_Allocator' filepath='src/base/stl_allocator.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::address(MemoryRegionMap::Region&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7addressERS1_' filepath='src/base/stl_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-744'/>
          <!-- MemoryRegionMap::Region* -->
          <return type-id='type-id-186'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::address(const MemoryRegionMap::Region&) -->
        <function-decl name='address' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7addressERKS1_' filepath='src/base/stl_allocator.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- const MemoryRegionMap::Region* -->
          <return type-id='type-id-185'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- MemoryRegionMap::Region* STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::allocate(unsigned long int, void*) -->
        <function-decl name='allocate' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE8allocateEmPKv' filepath='src/base/stl_allocator.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- MemoryRegionMap::Region* -->
          <return type-id='type-id-186'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::deallocate(MemoryRegionMap::Region*, unsigned long int) -->
        <function-decl name='deallocate' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE10deallocateEPS1_m' filepath='src/base/stl_allocator.h' line='86' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::max_size() -->
        <function-decl name='max_size' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE8max_sizeEv' filepath='src/base/stl_allocator.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::construct(MemoryRegionMap::Region*, const MemoryRegionMap::Region&) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE9constructEPS1_RKS1_' filepath='src/base/stl_allocator.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- parameter of type 'const MemoryRegionMap::Region&' -->
          <parameter type-id='type-id-183'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::construct(MemoryRegionMap::Region*) -->
        <function-decl name='construct' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE9constructEPS1_' filepath='src/base/stl_allocator.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::destroy(MemoryRegionMap::Region*) -->
        <function-decl name='destroy' mangled-name='_ZN13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEE7destroyEPS1_' filepath='src/base/stl_allocator.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'MemoryRegionMap::Region*' -->
          <parameter type-id='type-id-186'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::operator==(const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='operator==' mangled-name='_ZNK13STL_AllocatorIN15MemoryRegionMap6RegionENS0_11MyAllocatorEEeqERKS3_' filepath='src/base/stl_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-877' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-828'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>::STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region> >(const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
        <function-decl name='STL_Allocator&lt;std::_Rb_tree_node&lt;MemoryRegionMap::Region&gt; &gt;' filepath='src/base/stl_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>*' -->
          <parameter type-id='type-id-876' is-artificial='yes'/>
          <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
          <parameter type-id='type-id-878'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- HeapProfileBucket** -->
    <pointer-type-def type-id='type-id-205' size-in-bits='64' id='type-id-200'/>
    <!-- MemoryRegionMap::Region& -->
    <reference-type-def kind='lvalue' type-id='type-id-184' size-in-bits='64' id='type-id-744'/>
    <!-- MemoryRegionMap::RegionSet* -->
    <pointer-type-def type-id='type-id-188' size-in-bits='64' id='type-id-193'/>
    <!-- MemoryRegionMap::RegionSetRep* -->
    <pointer-type-def type-id='type-id-190' size-in-bits='64' id='type-id-192'/>
    <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-832' size-in-bits='64' id='type-id-876'/>
    <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-892' size-in-bits='64' id='type-id-895'/>
    <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-892' size-in-bits='64' id='type-id-930'/>
    <!-- const MemoryRegionMap::RegionCmp -->
    <qualified-type-def type-id='type-id-181' const='yes' id='type-id-837'/>
    <!-- const MemoryRegionMap::RegionCmp& -->
    <reference-type-def kind='lvalue' type-id='type-id-837' size-in-bits='64' id='type-id-827'/>
    <!-- const MemoryRegionMap::RegionCmp* -->
    <pointer-type-def type-id='type-id-837' size-in-bits='64' id='type-id-182'/>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
    <qualified-type-def type-id='type-id-832' const='yes' id='type-id-906'/>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-906' size-in-bits='64' id='type-id-828'/>
    <!-- const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-906' size-in-bits='64' id='type-id-877'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
    <qualified-type-def type-id='type-id-892' const='yes' id='type-id-942'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
    <reference-type-def kind='lvalue' type-id='type-id-942' size-in-bits='64' id='type-id-878'/>
    <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>* -->
    <pointer-type-def type-id='type-id-942' size-in-bits='64' id='type-id-931'/>
    <!-- const std::_Identity<MemoryRegionMap::Region> -->
    <qualified-type-def type-id='type-id-1095' const='yes' id='type-id-1096'/>
    <!-- const std::_Identity<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-1096' size-in-bits='64' id='type-id-1097'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
    <qualified-type-def type-id='type-id-825' const='yes' id='type-id-944'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-944' size-in-bits='64' id='type-id-897'/>
    <!-- const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-944' size-in-bits='64' id='type-id-896'/>
    <!-- const std::_Rb_tree_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-520' size-in-bits='64' id='type-id-743'/>
    <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-539' size-in-bits='64' id='type-id-933'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
    <qualified-type-def type-id='type-id-189' const='yes' id='type-id-912'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-912' size-in-bits='64' id='type-id-829'/>
    <!-- const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-912' size-in-bits='64' id='type-id-831'/>
    <!-- const volatile Atomic32 -->
    <qualified-type-def type-id='type-id-88' const='yes' id='type-id-105'/>
    <!-- const volatile Atomic32* -->
    <pointer-type-def type-id='type-id-105' size-in-bits='64' id='type-id-104'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-825' size-in-bits='64' id='type-id-898'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-825' size-in-bits='64' id='type-id-894'/>
    <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>* -->
    <pointer-type-def type-id='type-id-891' size-in-bits='64' id='type-id-893'/>
    <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-519' size-in-bits='64' id='type-id-745'/>
    <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-519' size-in-bits='64' id='type-id-741'/>
    <!-- std::_Rb_tree_node<MemoryRegionMap::Region>& -->
    <reference-type-def kind='lvalue' type-id='type-id-538' size-in-bits='64' id='type-id-932'/>
    <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
    <pointer-type-def type-id='type-id-538' size-in-bits='64' id='type-id-742'/>
    <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>* -->
    <pointer-type-def type-id='type-id-834' size-in-bits='64' id='type-id-926'/>
    <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>* -->
    <pointer-type-def type-id='type-id-900' size-in-bits='64' id='type-id-952'/>
    <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-189' size-in-bits='64' id='type-id-830'/>
    <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >* -->
    <pointer-type-def type-id='type-id-189' size-in-bits='64' id='type-id-826'/>
    <!-- void (const MemoryRegionMap::Region&)* -->
    <pointer-type-def type-id='type-id-857' size-in-bits='64' id='type-id-206'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- class std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
      <class-decl name='set&lt;MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='88' column='1' id='type-id-189'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-825' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='112' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set() -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set(const MemoryRegionMap::RegionCmp&, const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
            <parameter type-id='type-id-827'/>
            <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
            <parameter type-id='type-id-828'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::set(const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='set' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-829'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::operator=(const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEEaSERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-829'/>
            <!-- std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
            <return type-id='type-id-830'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='274' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='282' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
            <return type-id='type-id-832'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='300' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='361' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='371' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::swap(std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4swapERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='389' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-830'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::insert(const MemoryRegionMap::Region&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6insertERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='408' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> -->
            <return type-id='type-id-834'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::insert(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='insert' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6insertESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='435' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='475' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region&) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='490' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_ES8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='505' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='515' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::count(const MemoryRegionMap::Region&) -->
          <function-decl name='count' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5countERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='547' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='551' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='568' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='588' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='609' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-826' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3setIN15MemoryRegionMap6RegionENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_set.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::set<MemoryRegionMap::Region, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-831' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> > -->
      <class-decl name='_Rb_tree&lt;MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity&lt;MemoryRegionMap::Region&gt;, MemoryRegionMap::RegionCmp, STL_Allocator&lt;MemoryRegionMap::Region, MemoryRegionMap::MyAllocator&gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-825'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true> -->
          <class-decl name='_Rb_tree_impl&lt;MemoryRegionMap::RegionCmp, true&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-891'>
            <!-- class STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-892'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- MemoryRegionMap::RegionCmp std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-181' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_Rb_tree_impl(const MemoryRegionMap::RegionCmp&, const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
                <parameter type-id='type-id-827'/>
                <!-- parameter of type 'const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>&' -->
                <parameter type-id='type-id-878'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13_Rb_tree_implIS4_Lb1EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true>*' -->
                <parameter type-id='type-id-893' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree_impl<MemoryRegionMap::RegionCmp, true> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-891' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
            <return type-id='type-id-895'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const STL_Allocator<std::_Rb_tree_node<MemoryRegionMap::Region>, MemoryRegionMap::MyAllocator>& -->
            <return type-id='type-id-878'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> -->
            <return type-id='type-id-832'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_put_node(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_put_nodeEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_create_node(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_create_nodeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_destroy_node(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_clone_node(const std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_valueEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_S_keyEPKSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-540'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const MemoryRegionMap::Region& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE10_M_insert_EPKSt18_Rb_tree_node_baseSB_RKS1_'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_insert_lowerEPSt18_Rb_tree_node_baseSA_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal_lower(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE21_M_insert_equal_lowerERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_copy(const std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE7_M_copyEPKSt13_Rb_tree_nodeIS1_EPSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- std::_Rb_tree_node<MemoryRegionMap::Region>* -->
            <return type-id='type-id-742'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_erase(std::_Rb_tree_node<MemoryRegionMap::Region>*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8_M_eraseEPSt13_Rb_tree_nodeIS1_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_lower_bound(std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_lower_boundEPSt13_Rb_tree_nodeIS1_ESB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_lower_bound(const std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_lower_boundEPKSt13_Rb_tree_nodeIS1_ESC_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_upper_bound(std::_Rb_tree_node<MemoryRegionMap::Region>*, std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_upper_boundEPSt13_Rb_tree_nodeIS1_ESB_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-742'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_upper_bound(const std::_Rb_tree_node<MemoryRegionMap::Region>*, const std::_Rb_tree_node<MemoryRegionMap::Region>*, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE14_M_upper_boundEPKSt13_Rb_tree_nodeIS1_ESC_RKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const std::_Rb_tree_node<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-540'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree(const MemoryRegionMap::RegionCmp&, const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::RegionCmp&' -->
            <parameter type-id='type-id-827'/>
            <!-- parameter of type 'const STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator>&' -->
            <parameter type-id='type-id-828'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_Rb_tree(const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-897'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::operator=(const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEEaSERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-897'/>
            <!-- std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >& -->
            <return type-id='type-id-898'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MemoryRegionMap::RegionCmp std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct MemoryRegionMap::RegionCmp -->
            <return type-id='type-id-181'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-899'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-899'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-833'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::swap(std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4swapERS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >&' -->
            <parameter type-id='type-id-898'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_unique(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE16_M_insert_uniqueERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> -->
            <return type-id='type-id-900'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal(const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE15_M_insert_equalERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_unique_(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::_M_insert_equal_(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, const MemoryRegionMap::Region&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt17_Rb_tree_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt17_Rb_tree_iteratorIS1_ESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-519'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region>) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseESt23_Rb_tree_const_iteratorIS1_ESA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region>' -->
            <parameter type-id='type-id-198'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::erase(const MemoryRegionMap::Region*, const MemoryRegionMap::Region*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5eraseEPKS1_SA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region*' -->
            <parameter type-id='type-id-185'/>
            <!-- parameter of type 'const MemoryRegionMap::Region*' -->
            <parameter type-id='type-id-185'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::find(const MemoryRegionMap::Region&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE4findERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::count(const MemoryRegionMap::Region&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE5countERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::lower_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11lower_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-519'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::upper_bound(const MemoryRegionMap::Region&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11upper_boundERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::_Rb_tree_const_iterator<MemoryRegionMap::Region> -->
            <return type-id='type-id-198'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-894' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-901'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::equal_range(const MemoryRegionMap::Region&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11equal_rangeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
            <return type-id='type-id-835'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeIN15MemoryRegionMap6RegionES1_St9_IdentityIS1_ENS0_9RegionCmpE13STL_AllocatorIS1_NS0_11MyAllocatorEEE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<MemoryRegionMap::Region, MemoryRegionMap::Region, std::_Identity<MemoryRegionMap::Region>, MemoryRegionMap::RegionCmp, STL_Allocator<MemoryRegionMap::Region, MemoryRegionMap::MyAllocator> >*' -->
            <parameter type-id='type-id-896' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Identity<MemoryRegionMap::Region> -->
      <class-decl name='_Identity&lt;MemoryRegionMap::Region&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='469' column='1' id='type-id-1095'>
        <!-- struct std::unary_function<MemoryRegionMap::Region, MemoryRegionMap::Region> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1098'/>
        <member-function access='public'>
          <!-- MemoryRegionMap::Region& std::_Identity<MemoryRegionMap::Region>::operator()(MemoryRegionMap::Region&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt9_IdentityIN15MemoryRegionMap6RegionEEclERS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Identity<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-1097' is-artificial='yes'/>
            <!-- parameter of type 'MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-744'/>
            <!-- MemoryRegionMap::Region& -->
            <return type-id='type-id-744'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const MemoryRegionMap::Region& std::_Identity<MemoryRegionMap::Region>::operator()(const MemoryRegionMap::Region&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt9_IdentityIN15MemoryRegionMap6RegionEEclERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='475' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Identity<MemoryRegionMap::Region>*' -->
            <parameter type-id='type-id-1097' is-artificial='yes'/>
            <!-- parameter of type 'const MemoryRegionMap::Region&' -->
            <parameter type-id='type-id-183'/>
            <!-- const MemoryRegionMap::Region& -->
            <return type-id='type-id-183'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<MemoryRegionMap::Region, MemoryRegionMap::Region> -->
      <class-decl name='unary_function&lt;MemoryRegionMap::Region, MemoryRegionMap::Region&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-1098'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-900'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<MemoryRegionMap::Region> std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::first -->
          <var-decl name='first' type-id='type-id-519' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-952' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>::pair(const std::_Rb_tree_iterator<MemoryRegionMap::Region>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-952' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-521'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-834'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_const_iterator<MemoryRegionMap::Region> std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::first -->
          <var-decl name='first' type-id='type-id-198' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-926' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>::pair(const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, bool>*' -->
            <parameter type-id='type-id-926' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<MemoryRegionMap::Region>&' -->
            <parameter type-id='type-id-501'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<const void**, false> -->
      <class-decl name='__miter_base&lt;const void**, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-1099'>
        <member-function access='public' static='yes'>
          <!-- void** std::__miter_base<const void**, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPPKvLb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- bool std::__equal_aux<const void**, const void**>(void**, void**, void**) -->
      <function-decl name='__equal_aux&lt;const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='822' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void** std::__copy_move_a<false, const void**, const void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_a&lt;false, const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- void** std::__copy_move_a2<false, const void**, const void**>(void**, void**, void**) -->
      <function-decl name='__copy_move_a2&lt;false, const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- bool std::equal<const void**, const void**>(void**, void**, void**) -->
      <function-decl name='equal&lt;const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='952' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- bool -->
        <return type-id='type-id-55'/>
      </function-decl>
      <!-- void** std::copy<const void**, const void**>(void**, void**, void**) -->
      <function-decl name='copy&lt;const void**, const void**&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void** -->
        <return type-id='type-id-141'/>
      </function-decl>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-899'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-833'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<MemoryRegionMap::Region>, std::_Rb_tree_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt;, std::_Rb_tree_iterator&lt;MemoryRegionMap::Region&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-901'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<MemoryRegionMap::Region>, std::_Rb_tree_const_iterator<MemoryRegionMap::Region> > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt;, std::_Rb_tree_const_iterator&lt;MemoryRegionMap::Region&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-835'/>
    </namespace-decl>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- namespace base::subtle -->
      <namespace-decl name='subtle'>
        <!-- Atomic32 base::subtle::NoBarrier_Load(const volatile Atomic32*) -->
        <function-decl name='NoBarrier_Load' filepath='./src/base/atomicops-internals-x86.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const volatile Atomic32*' -->
          <parameter type-id='type-id-104'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- void (const MemoryRegionMap::Region&) -->
    <function-type size-in-bits='64' id='type-id-857'>
      <!-- parameter of type 'const MemoryRegionMap::Region&' -->
      <parameter type-id='type-id-183'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/page_heap.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- namespace tcmalloc::commandlineflags -->
      <namespace-decl name='commandlineflags'>
        <!-- double tcmalloc::commandlineflags::StringToDouble(const char*, double) -->
        <function-decl name='StringToDouble' filepath='src/base/commandlineflags.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'double' -->
          <parameter type-id='type-id-2'/>
          <!-- double -->
          <return type-id='type-id-2'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead'>
      <!-- double FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead::FLAGS_tcmalloc_release_rate -->
      <var-decl name='FLAGS_tcmalloc_release_rate' type-id='type-id-2' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead27FLAGS_tcmalloc_release_rateE' visibility='default' filepath='src/page_heap.cc' line='46' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead27FLAGS_tcmalloc_release_rateE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead::FLAGS_notcmalloc_release_rate -->
      <var-decl name='FLAGS_notcmalloc_release_rate' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead29FLAGS_notcmalloc_release_rateE' visibility='default' filepath='src/page_heap.cc' line='52' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead29FLAGS_notcmalloc_release_rateE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_heap_limit_mb -->
      <var-decl name='FLAGS_tcmalloc_heap_limit_mb' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead28FLAGS_tcmalloc_heap_limit_mbE' visibility='default' filepath='src/page_heap.cc' line='54' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead28FLAGS_tcmalloc_heap_limit_mbE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_heap_limit_mb -->
      <var-decl name='FLAGS_notcmalloc_heap_limit_mb' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead30FLAGS_notcmalloc_heap_limit_mbE' visibility='default' filepath='src/page_heap.cc' line='60' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead30FLAGS_notcmalloc_heap_limit_mbE'/>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/profile-handler.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- typedef void (int, siginfo_t*, void*, void*)* ProfileHandlerCallback -->
    <typedef-decl name='ProfileHandlerCallback' type-id='type-id-1100' filepath='src/profile-handler.h' line='95' column='1' id='type-id-1101'/>
    <!-- struct timer_id_holder -->
    <class-decl name='timer_id_holder' size-in-bits='64' is-struct='yes' visibility='default' filepath='src/profile-handler.cc' line='266' column='1' id='type-id-1102'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- timer_t timer_id_holder::timerid -->
        <var-decl name='timerid' type-id='type-id-1103' visibility='default' filepath='src/profile-handler.cc' line='267' column='1'/>
      </data-member>
      <member-function access='public' constructor='yes'>
        <!-- timer_id_holder::timer_id_holder(timer_t) -->
        <function-decl name='timer_id_holder' filepath='src/profile-handler.cc' line='268' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'timer_id_holder*' -->
          <parameter type-id='type-id-1104' is-artificial='yes'/>
          <!-- parameter of type 'typedef timer_t' -->
          <parameter type-id='type-id-1103'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef __timer_t timer_t -->
    <typedef-decl name='timer_t' type-id='type-id-1105' filepath='/usr/include/time.h' line='104' column='1' id='type-id-1103'/>
    <!-- typedef void* __timer_t -->
    <typedef-decl name='__timer_t' type-id='type-id-53' filepath='/usr/include/bits/types.h' line='161' column='1' id='type-id-1105'/>
    <!-- class ProfileHandler -->
    <class-decl name='ProfileHandler' size-in-bits='448' visibility='default' filepath='src/profile-handler.cc' line='84' column='1' id='type-id-1106'>
      <member-type access='private'>
        <!-- enum ProfileHandler::__anonymous_enum__ -->
        <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='src/profile-handler.cc' line='166' column='1' id='type-id-1107'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='TIMERS_UNTOUCHED' value='0'/>
          <enumerator name='TIMERS_ONE_SET' value='1'/>
          <enumerator name='TIMERS_SHARED' value='2'/>
          <enumerator name='TIMERS_SEPARATE' value='3'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > ProfileHandler::CallbackList -->
        <typedef-decl name='CallbackList' type-id='type-id-1109' filepath='src/profile-handler.cc' line='199' column='1' id='type-id-1108'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef std::_List_iterator<ProfileHandlerToken*> ProfileHandler::CallbackIterator -->
        <typedef-decl name='CallbackIterator' type-id='type-id-1111' filepath='src/profile-handler.cc' line='200' column='1' id='type-id-1110'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const int32 ProfileHandler::kMaxFrequency -->
        <var-decl name='kMaxFrequency' type-id='type-id-1112' mangled-name='_ZN14ProfileHandler13kMaxFrequencyE' visibility='default' filepath='src/profile-handler.cc' line='128' column='1' elf-symbol-id='_ZN14ProfileHandler13kMaxFrequencyE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int32 ProfileHandler::kDefaultFrequency -->
        <var-decl name='kDefaultFrequency' type-id='type-id-1112' mangled-name='_ZN14ProfileHandler17kDefaultFrequencyE' visibility='default' filepath='src/profile-handler.cc' line='130' column='1' elf-symbol-id='_ZN14ProfileHandler17kDefaultFrequencyE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static ProfileHandler* ProfileHandler::instance_ -->
        <var-decl name='instance_' type-id='type-id-1113' mangled-name='_ZN14ProfileHandler9instance_E' visibility='default' filepath='src/profile-handler.cc' line='133' column='1' elf-symbol-id='_ZN14ProfileHandler9instance_E'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static pthread_once_t ProfileHandler::once_ -->
        <var-decl name='once_' type-id='type-id-1091' mangled-name='_ZN14ProfileHandler5once_E' visibility='default' filepath='src/profile-handler.cc' line='136' column='1' elf-symbol-id='_ZN14ProfileHandler5once_E'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- int64 ProfileHandler::interrupts_ -->
        <var-decl name='interrupts_' type-id='type-id-93' visibility='default' filepath='src/profile-handler.cc' line='142' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- int32 ProfileHandler::frequency_ -->
        <var-decl name='frequency_' type-id='type-id-69' visibility='default' filepath='src/profile-handler.cc' line='145' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='96'>
        <!-- int ProfileHandler::timer_type_ -->
        <var-decl name='timer_type_' type-id='type-id-1' visibility='default' filepath='src/profile-handler.cc' line='148' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- int32 ProfileHandler::callback_count_ -->
        <var-decl name='callback_count_' type-id='type-id-69' visibility='default' filepath='src/profile-handler.cc' line='151' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='160'>
        <!-- bool ProfileHandler::allowed_ -->
        <var-decl name='allowed_' type-id='type-id-55' visibility='default' filepath='src/profile-handler.cc' line='154' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='168'>
        <!-- bool ProfileHandler::per_thread_timer_enabled_ -->
        <var-decl name='per_thread_timer_enabled_' type-id='type-id-55' visibility='default' filepath='src/profile-handler.cc' line='156' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- pthread_key_t ProfileHandler::thread_timer_key -->
        <var-decl name='thread_timer_key' type-id='type-id-1089' visibility='default' filepath='src/profile-handler.cc' line='161' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='224'>
        <!-- ProfileHandler::__anonymous_enum__ ProfileHandler::timer_sharing_ -->
        <var-decl name='timer_sharing_' type-id='type-id-1107' visibility='default' filepath='src/profile-handler.cc' line='175' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- SpinLock ProfileHandler::control_lock_ -->
        <var-decl name='control_lock_' type-id='type-id-82' visibility='default' filepath='src/profile-handler.cc' line='183' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='288'>
        <!-- SpinLock ProfileHandler::signal_lock_ -->
        <var-decl name='signal_lock_' type-id='type-id-82' visibility='default' filepath='src/profile-handler.cc' line='184' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='320'>
        <!-- ProfileHandler::CallbackList ProfileHandler::callbacks_ -->
        <var-decl name='callbacks_' type-id='type-id-1108' visibility='default' filepath='src/profile-handler.cc' line='201' column='1'/>
      </data-member>
      <member-function access='private'>
        <!-- void ProfileHandler::RegisterThread() -->
        <function-decl name='RegisterThread' mangled-name='_ZN14ProfileHandler14RegisterThreadEv' filepath='src/profile-handler.cc' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler14RegisterThreadEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- ProfileHandlerToken* ProfileHandler::RegisterCallback(ProfileHandlerCallback, void*) -->
        <function-decl name='RegisterCallback' mangled-name='_ZN14ProfileHandler16RegisterCallbackEPFviP7siginfoPvS2_ES2_' filepath='src/profile-handler.cc' line='104' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler16RegisterCallbackEPFviP7siginfoPvS2_ES2_'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- parameter of type 'typedef ProfileHandlerCallback' -->
          <parameter type-id='type-id-1101'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- ProfileHandlerToken* -->
          <return type-id='type-id-1114'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::UnregisterCallback(ProfileHandlerToken*) -->
        <function-decl name='UnregisterCallback' mangled-name='_ZN14ProfileHandler18UnregisterCallbackEP19ProfileHandlerToken' filepath='src/profile-handler.cc' line='110' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler18UnregisterCallbackEP19ProfileHandlerToken'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- parameter of type 'ProfileHandlerToken*' -->
          <parameter type-id='type-id-1114'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::Reset() -->
        <function-decl name='Reset' mangled-name='_ZN14ProfileHandler5ResetEv' filepath='src/profile-handler.cc' line='115' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler5ResetEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::GetState(ProfileHandlerState*) -->
        <function-decl name='GetState' mangled-name='_ZN14ProfileHandler8GetStateEP19ProfileHandlerState' filepath='src/profile-handler.cc' line='118' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler8GetStateEP19ProfileHandlerState'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- parameter of type 'ProfileHandlerState*' -->
          <parameter type-id='type-id-1115'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- ProfileHandler* ProfileHandler::Instance() -->
        <function-decl name='Instance' mangled-name='_ZN14ProfileHandler8InstanceEv' filepath='src/profile-handler.cc' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler8InstanceEv'>
          <!-- ProfileHandler* -->
          <return type-id='type-id-1113'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- ProfileHandler::ProfileHandler() -->
        <function-decl name='ProfileHandler' mangled-name='_ZN14ProfileHandlerC1Ev' filepath='src/profile-handler.cc' line='124' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandlerC1Ev'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- ProfileHandler::~ProfileHandler(int) -->
        <function-decl name='~ProfileHandler' mangled-name='_ZN14ProfileHandlerD1Ev' filepath='src/profile-handler.cc' line='125' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandlerD1Ev'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void ProfileHandler::Init() -->
        <function-decl name='Init' mangled-name='_ZN14ProfileHandler4InitEv' filepath='src/profile-handler.cc' line='139' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler4InitEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::StartTimer() -->
        <function-decl name='StartTimer' mangled-name='_ZN14ProfileHandler10StartTimerEv' filepath='src/profile-handler.cc' line='206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler10StartTimerEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::StopTimer() -->
        <function-decl name='StopTimer' mangled-name='_ZN14ProfileHandler9StopTimerEv' filepath='src/profile-handler.cc' line='211' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler9StopTimerEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProfileHandler::IsTimerRunning() -->
        <function-decl name='IsTimerRunning' mangled-name='_ZN14ProfileHandler14IsTimerRunningEv' filepath='src/profile-handler.cc' line='216' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler14IsTimerRunningEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::EnableHandler() -->
        <function-decl name='EnableHandler' mangled-name='_ZN14ProfileHandler13EnableHandlerEv' filepath='src/profile-handler.cc' line='219' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler13EnableHandlerEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::DisableHandler() -->
        <function-decl name='DisableHandler' mangled-name='_ZN14ProfileHandler14DisableHandlerEv' filepath='src/profile-handler.cc' line='222' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler14DisableHandlerEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProfileHandler::IsSignalHandlerAvailable() -->
        <function-decl name='IsSignalHandlerAvailable' mangled-name='_ZN14ProfileHandler24IsSignalHandlerAvailableEv' filepath='src/profile-handler.cc' line='226' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler24IsSignalHandlerAvailableEv'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void ProfileHandler::SignalHandler(siginfo_t*, void*) -->
        <function-decl name='SignalHandler' mangled-name='_ZN14ProfileHandler13SignalHandlerEiP7siginfoPv' filepath='src/profile-handler.cc' line='229' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14ProfileHandler13SignalHandlerEiP7siginfoPv'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'siginfo_t*' -->
          <parameter type-id='type-id-1116'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- ProfileHandler::ProfileHandler(const ProfileHandler&) -->
        <function-decl name='ProfileHandler' filepath='src/profile-handler.cc' line='231' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- parameter of type 'const ProfileHandler&' -->
          <parameter type-id='type-id-1117'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileHandler::operator=(const ProfileHandler&) -->
        <function-decl name='operator=' mangled-name='_ZN14ProfileHandleraSERKS_' filepath='src/profile-handler.cc' line='231' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileHandler*' -->
          <parameter type-id='type-id-1113' is-artificial='yes'/>
          <!-- parameter of type 'const ProfileHandler&' -->
          <parameter type-id='type-id-1117'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef int pthread_once_t -->
    <typedef-decl name='pthread_once_t' type-id='type-id-1' filepath='/usr/include/bits/pthreadtypes.h' line='144' column='1' id='type-id-1091'/>
    <!-- struct ProfileHandlerState -->
    <class-decl name='ProfileHandlerState' size-in-bits='192' is-struct='yes' visibility='default' filepath='src/profile-handler.h' line='137' column='1' id='type-id-1118'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int32 ProfileHandlerState::frequency -->
        <var-decl name='frequency' type-id='type-id-69' visibility='default' filepath='src/profile-handler.h' line='138' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int32 ProfileHandlerState::callback_count -->
        <var-decl name='callback_count' type-id='type-id-69' visibility='default' filepath='src/profile-handler.h' line='139' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int64 ProfileHandlerState::interrupts -->
        <var-decl name='interrupts' type-id='type-id-93' visibility='default' filepath='src/profile-handler.h' line='140' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- bool ProfileHandlerState::allowed -->
        <var-decl name='allowed' type-id='type-id-55' visibility='default' filepath='src/profile-handler.h' line='141' column='1'/>
      </data-member>
    </class-decl>
    <!-- ProfileHandler* -->
    <pointer-type-def type-id='type-id-1106' size-in-bits='64' id='type-id-1113'/>
    <!-- ProfileHandlerState* -->
    <pointer-type-def type-id='type-id-1118' size-in-bits='64' id='type-id-1115'/>
    <!-- ProfileHandlerToken* const -->
    <qualified-type-def type-id='type-id-1114' const='yes' id='type-id-1119'/>
    <!-- ProfileHandlerToken* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-1119' size-in-bits='64' id='type-id-1120'/>
    <!-- ProfileHandlerToken* const* -->
    <pointer-type-def type-id='type-id-1119' size-in-bits='64' id='type-id-1121'/>
    <!-- ProfileHandlerToken*& -->
    <reference-type-def kind='lvalue' type-id='type-id-1114' size-in-bits='64' id='type-id-1122'/>
    <!-- ProfileHandlerToken** -->
    <pointer-type-def type-id='type-id-1114' size-in-bits='64' id='type-id-1123'/>
    <!-- __gnu_cxx::new_allocator<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1124' size-in-bits='64' id='type-id-1125'/>
    <!-- __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1126' size-in-bits='64' id='type-id-1127'/>
    <!-- const ProfileHandler -->
    <qualified-type-def type-id='type-id-1106' const='yes' id='type-id-1128'/>
    <!-- const ProfileHandler& -->
    <reference-type-def kind='lvalue' type-id='type-id-1128' size-in-bits='64' id='type-id-1117'/>
    <!-- const __gnu_cxx::new_allocator<ProfileHandlerToken*> -->
    <qualified-type-def type-id='type-id-1124' const='yes' id='type-id-1129'/>
    <!-- const __gnu_cxx::new_allocator<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1129' size-in-bits='64' id='type-id-1130'/>
    <!-- const __gnu_cxx::new_allocator<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1129' size-in-bits='64' id='type-id-1131'/>
    <!-- const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> > -->
    <qualified-type-def type-id='type-id-1126' const='yes' id='type-id-1132'/>
    <!-- const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1132' size-in-bits='64' id='type-id-1133'/>
    <!-- const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1132' size-in-bits='64' id='type-id-1134'/>
    <!-- const int32 -->
    <qualified-type-def type-id='type-id-69' const='yes' id='type-id-1112'/>
    <!-- const std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > -->
    <qualified-type-def type-id='type-id-1135' const='yes' id='type-id-1136'/>
    <!-- const std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1136' size-in-bits='64' id='type-id-1137'/>
    <!-- const std::_List_iterator<ProfileHandlerToken*> -->
    <qualified-type-def type-id='type-id-1111' const='yes' id='type-id-1138'/>
    <!-- const std::_List_iterator<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1138' size-in-bits='64' id='type-id-1139'/>
    <!-- const std::_List_iterator<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1138' size-in-bits='64' id='type-id-1140'/>
    <!-- const std::_List_node<ProfileHandlerToken*> -->
    <qualified-type-def type-id='type-id-1141' const='yes' id='type-id-1142'/>
    <!-- const std::_List_node<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1142' size-in-bits='64' id='type-id-1143'/>
    <!-- const std::_List_node<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1142' size-in-bits='64' id='type-id-1144'/>
    <!-- const std::allocator<ProfileHandlerToken*> -->
    <qualified-type-def type-id='type-id-1145' const='yes' id='type-id-1146'/>
    <!-- const std::allocator<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1146' size-in-bits='64' id='type-id-1147'/>
    <!-- const std::allocator<std::_List_node<ProfileHandlerToken*> > -->
    <qualified-type-def type-id='type-id-1148' const='yes' id='type-id-1149'/>
    <!-- const std::allocator<std::_List_node<ProfileHandlerToken*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1149' size-in-bits='64' id='type-id-1150'/>
    <!-- const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > -->
    <qualified-type-def type-id='type-id-1109' const='yes' id='type-id-1151'/>
    <!-- const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1151' size-in-bits='64' id='type-id-1152'/>
    <!-- const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1151' size-in-bits='64' id='type-id-1153'/>
    <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1135' size-in-bits='64' id='type-id-1154'/>
    <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl* -->
    <pointer-type-def type-id='type-id-1155' size-in-bits='64' id='type-id-1156'/>
    <!-- std::_List_iterator<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1111' size-in-bits='64' id='type-id-1157'/>
    <!-- std::_List_iterator<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1111' size-in-bits='64' id='type-id-1158'/>
    <!-- std::_List_node<ProfileHandlerToken*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1141' size-in-bits='64' id='type-id-1159'/>
    <!-- std::_List_node<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1141' size-in-bits='64' id='type-id-1160'/>
    <!-- std::_List_node_base& -->
    <reference-type-def kind='lvalue' type-id='type-id-1161' size-in-bits='64' id='type-id-1162'/>
    <!-- std::_List_node_base* -->
    <pointer-type-def type-id='type-id-1161' size-in-bits='64' id='type-id-1163'/>
    <!-- std::allocator<ProfileHandlerToken*>* -->
    <pointer-type-def type-id='type-id-1145' size-in-bits='64' id='type-id-1164'/>
    <!-- std::allocator<std::_List_node<ProfileHandlerToken*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1148' size-in-bits='64' id='type-id-1165'/>
    <!-- std::allocator<std::_List_node<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1148' size-in-bits='64' id='type-id-1166'/>
    <!-- std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1109' size-in-bits='64' id='type-id-1167'/>
    <!-- std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >* -->
    <pointer-type-def type-id='type-id-1109' size-in-bits='64' id='type-id-1168'/>
    <!-- timer_id_holder* -->
    <pointer-type-def type-id='type-id-1102' size-in-bits='64' id='type-id-1104'/>
    <!-- void (int, siginfo_t*, void*, void*)* -->
    <pointer-type-def type-id='type-id-1169' size-in-bits='64' id='type-id-1100'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
      <class-decl name='_List_iterator&lt;ProfileHandlerToken*&gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='114' column='1' id='type-id-1111'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_List_node_base* std::_List_iterator<ProfileHandlerToken*>::_M_node -->
          <var-decl name='_M_node' type-id='type-id-1163' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='179' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_List_iterator<ProfileHandlerToken*>::_List_iterator() -->
          <function-decl name='_List_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_List_iterator<ProfileHandlerToken*>::_List_iterator(std::_List_node_base*) -->
          <function-decl name='_List_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- ProfileHandlerToken*& std::_List_iterator<ProfileHandlerToken*>::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt14_List_iteratorIP19ProfileHandlerTokenEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1140' is-artificial='yes'/>
            <!-- ProfileHandlerToken*& -->
            <return type-id='type-id-1122'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- ProfileHandlerToken** std::_List_iterator<ProfileHandlerToken*>::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt14_List_iteratorIP19ProfileHandlerTokenEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1140' is-artificial='yes'/>
            <!-- ProfileHandlerToken** -->
            <return type-id='type-id-1123'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_List_iterator<ProfileHandlerToken*>& std::_List_iterator<ProfileHandlerToken*>::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt14_List_iteratorIP19ProfileHandlerTokenEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='141' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- std::_List_iterator<ProfileHandlerToken*>& -->
            <return type-id='type-id-1157'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::_List_iterator<ProfileHandlerToken*>::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt14_List_iteratorIP19ProfileHandlerTokenEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_List_iterator<ProfileHandlerToken*>& std::_List_iterator<ProfileHandlerToken*>::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt14_List_iteratorIP19ProfileHandlerTokenEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- std::_List_iterator<ProfileHandlerToken*>& -->
            <return type-id='type-id-1157'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::_List_iterator<ProfileHandlerToken*>::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt14_List_iteratorIP19ProfileHandlerTokenEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1158' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_List_iterator<ProfileHandlerToken*>::operator==(const std::_List_iterator<ProfileHandlerToken*>&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt14_List_iteratorIP19ProfileHandlerTokenEeqERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='171' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1140' is-artificial='yes'/>
            <!-- parameter of type 'const std::_List_iterator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1139'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_List_iterator<ProfileHandlerToken*>::operator!=(const std::_List_iterator<ProfileHandlerToken*>&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt14_List_iteratorIP19ProfileHandlerTokenEneERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='175' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_iterator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1140' is-artificial='yes'/>
            <!-- parameter of type 'const std::_List_iterator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1139'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_List_node_base -->
      <class-decl name='_List_node_base' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='72' column='1' id='type-id-1161'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_List_node_base* std::_List_node_base::_M_next -->
          <var-decl name='_M_next' type-id='type-id-1163' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='73' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- std::_List_node_base* std::_List_node_base::_M_prev -->
          <var-decl name='_M_prev' type-id='type-id-1163' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='74' column='1'/>
        </data-member>
        <member-function access='public' static='yes'>
          <!-- void std::_List_node_base::swap(std::_List_node_base&) -->
          <function-decl name='swap' mangled-name='_ZNSt15_List_node_base4swapERS_S0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_List_node_base&' -->
            <parameter type-id='type-id-1162'/>
            <!-- parameter of type 'std::_List_node_base&' -->
            <parameter type-id='type-id-1162'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_List_node_base::transfer(std::_List_node_base*, std::_List_node_base*) -->
          <function-decl name='transfer' mangled-name='_ZNSt15_List_node_base8transferEPS_S0_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163'/>
            <!-- parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_List_node_base::reverse() -->
          <function-decl name='reverse' mangled-name='_ZNSt15_List_node_base7reverseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_List_node_base::hook(std::_List_node_base*) -->
          <function-decl name='hook' mangled-name='_ZNSt15_List_node_base4hookEPS_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='87' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_List_node_base::unhook() -->
          <function-decl name='unhook' mangled-name='_ZNSt15_List_node_base6unhookEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_node_base*' -->
            <parameter type-id='type-id-1163' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > -->
      <class-decl name='list&lt;ProfileHandlerToken*, std::allocator&lt;ProfileHandlerToken*&gt; &gt;' size-in-bits='128' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='418' column='1' id='type-id-1109'>
        <!-- class std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-1135'/>
        <member-function access='protected'>
          <!-- std::_List_node<ProfileHandlerToken*>* std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_create_node(ProfileHandlerToken* const&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE14_M_create_nodeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='459' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- std::_List_node<ProfileHandlerToken*>* -->
            <return type-id='type-id-1160'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::list() -->
          <function-decl name='list' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::list(const std::allocator<ProfileHandlerToken*>&) -->
          <function-decl name='list' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='507' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1147'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::list(unsigned long int, ProfileHandlerToken* const&, const std::allocator<ProfileHandlerToken*>&) -->
          <function-decl name='list' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='519' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- parameter of type 'const std::allocator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1147'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::list(const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='list' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='531' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1152'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >& std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::operator=(const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EEaSERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='132' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1152'/>
            <!-- std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >& -->
            <return type-id='type-id-1167'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::assign(unsigned long int, ProfileHandlerToken* const&) -->
          <function-decl name='assign' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='641' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='680' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- class std::allocator<ProfileHandlerToken*> -->
            <return type-id='type-id-1145'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='689' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_const_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- struct std::_List_const_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1170'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='707' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_const_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='716' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- struct std::_List_const_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1170'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_List_iterator<ProfileHandlerToken*> > std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_List_iterator<ProfileHandlerToken*> > -->
            <return type-id='type-id-1171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_List_const_iterator<ProfileHandlerToken*> > std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_List_const_iterator<ProfileHandlerToken*> > -->
            <return type-id='type-id-1172'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_List_iterator<ProfileHandlerToken*> > std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='743' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_List_iterator<ProfileHandlerToken*> > -->
            <return type-id='type-id-1171'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_List_const_iterator<ProfileHandlerToken*> > std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_List_const_iterator<ProfileHandlerToken*> > -->
            <return type-id='type-id-1172'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='804' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='809' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::resize(unsigned long int, ProfileHandlerToken*) -->
          <function-decl name='resize' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6resizeEmS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='117' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken*' -->
            <parameter type-id='type-id-1114'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken*& std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='831' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- ProfileHandlerToken*& -->
            <return type-id='type-id-1122'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken* const& std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='839' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- ProfileHandlerToken* const& -->
            <return type-id='type-id-1120'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken*& std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='847' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- ProfileHandlerToken*& -->
            <return type-id='type-id-1122'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken* const& std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt4listIP19ProfileHandlerTokenSaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='859' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1153' is-artificial='yes'/>
            <!-- ProfileHandlerToken* const& -->
            <return type-id='type-id-1120'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::push_front(ProfileHandlerToken* const&) -->
          <function-decl name='push_front' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE10push_frontERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='878' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::pop_front() -->
          <function-decl name='pop_front' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE9pop_frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='905' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::push_back(ProfileHandlerToken* const&) -->
          <function-decl name='push_back' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE9push_backERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='919' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='945' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::insert(std::_List_iterator<ProfileHandlerToken*>, ProfileHandlerToken* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6insertESt14_List_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::insert(std::_List_iterator<ProfileHandlerToken*>, unsigned long int, ProfileHandlerToken* const&) -->
          <function-decl name='insert' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6insertESt14_List_iteratorIS1_EmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1027' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::erase(std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='erase' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5eraseESt14_List_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_iterator<ProfileHandlerToken*> std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::erase(std::_List_iterator<ProfileHandlerToken*>, std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='erase' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5eraseESt14_List_iteratorIS1_ES5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1092' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- struct std::_List_iterator<ProfileHandlerToken*> -->
            <return type-id='type-id-1111'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::swap(std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE4swapERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1112' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1130' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::splice(std::_List_iterator<ProfileHandlerToken*>, std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='splice' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1152' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::splice(std::_List_iterator<ProfileHandlerToken*>, std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&, std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='splice' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_S5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1176' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::splice(std::_List_iterator<ProfileHandlerToken*>, std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&, std::_List_iterator<ProfileHandlerToken*>, std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='splice' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_S5_S5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::remove(ProfileHandlerToken* const&) -->
          <function-decl name='remove' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6removeERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::unique() -->
          <function-decl name='unique' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE6uniqueEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::merge(std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='merge' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE5mergeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='234' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::reverse() -->
          <function-decl name='reverse' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE7reverseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1320' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::sort() -->
          <function-decl name='sort' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE4sortEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='301' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_fill_initialize(unsigned long int, ProfileHandlerToken* const&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE18_M_fill_initializeEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_fill_assign(unsigned long int, ProfileHandlerToken* const&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE14_M_fill_assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='154' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_transfer(std::_List_iterator<ProfileHandlerToken*>, std::_List_iterator<ProfileHandlerToken*>, std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='_M_transfer' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE11_M_transferESt14_List_iteratorIS1_ES5_S5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1399' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_insert(std::_List_iterator<ProfileHandlerToken*>, ProfileHandlerToken* const&) -->
          <function-decl name='_M_insert' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE9_M_insertESt14_List_iteratorIS1_ERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1405' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_erase(std::_List_iterator<ProfileHandlerToken*>) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE8_M_eraseESt14_List_iteratorIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1422' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_List_iterator<ProfileHandlerToken*>' -->
            <parameter type-id='type-id-1111'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_check_equal_allocators(std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&) -->
          <function-decl name='_M_check_equal_allocators' mangled-name='_ZNSt4listIP19ProfileHandlerTokenSaIS1_EE25_M_check_equal_allocatorsERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='1436' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1168' is-artificial='yes'/>
            <!-- parameter of type 'std::list<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1167'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<std::_List_node<ProfileHandlerToken*> > -->
      <class-decl name='allocator&lt;std::_List_node&lt;ProfileHandlerToken*&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-1148'>
        <!-- class __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1126'/>
        <member-function access='private'>
          <!-- void std::allocator<std::_List_node<ProfileHandlerToken*> >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1166' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::_List_node<ProfileHandlerToken*> >::allocator(const std::allocator<std::_List_node<ProfileHandlerToken*> >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1166' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_List_node<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1150'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::_List_node<ProfileHandlerToken*> >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1166' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> > -->
      <class-decl name='_List_base&lt;ProfileHandlerToken*, std::allocator&lt;ProfileHandlerToken*&gt; &gt;' size-in-bits='128' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='278' column='1' id='type-id-1135'>
        <member-type access='protected'>
          <!-- struct std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl -->
          <class-decl name='_List_impl' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='300' column='1' id='type-id-1155'>
            <!-- class std::allocator<std::_List_node<ProfileHandlerToken*> > -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1148'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::_List_node_base std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl::_M_node -->
              <var-decl name='_M_node' type-id='type-id-1161' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='301' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl::_List_impl() -->
              <function-decl name='_List_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='303' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl*' -->
                <parameter type-id='type-id-1156' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl::_List_impl(const std::allocator<std::_List_node<ProfileHandlerToken*> >&) -->
              <function-decl name='_List_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='307' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl*' -->
                <parameter type-id='type-id-1156' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<std::_List_node<ProfileHandlerToken*> >&' -->
                <parameter type-id='type-id-1150'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_impl std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-1155' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='312' column='1'/>
        </data-member>
        <member-function access='protected'>
          <!-- std::_List_node<ProfileHandlerToken*>* std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- std::_List_node<ProfileHandlerToken*>* -->
            <return type-id='type-id-1160'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_put_node(std::_List_node<ProfileHandlerToken*>*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE11_M_put_nodeEPSt10_List_nodeIS1_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='319' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1160'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::_List_node<ProfileHandlerToken*> >& std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='326' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- std::allocator<std::_List_node<ProfileHandlerToken*> >& -->
            <return type-id='type-id-1165'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::allocator<std::_List_node<ProfileHandlerToken*> >& std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1137' is-artificial='yes'/>
            <!-- const std::allocator<std::_List_node<ProfileHandlerToken*> >& -->
            <return type-id='type-id-1150'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<ProfileHandlerToken*> std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='334' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1137' is-artificial='yes'/>
            <!-- class std::allocator<ProfileHandlerToken*> -->
            <return type-id='type-id-1145'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<ProfileHandlerToken*> std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='338' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1137' is-artificial='yes'/>
            <!-- class std::allocator<ProfileHandlerToken*> -->
            <return type-id='type-id-1145'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_base() -->
          <function-decl name='_List_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_List_base(const std::allocator<ProfileHandlerToken*>&) -->
          <function-decl name='_List_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1147'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::~_List_base(int) -->
          <function-decl name='~_List_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='359' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_clear() -->
          <function-decl name='_M_clear' mangled-name='_ZNSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE8_M_clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/list.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >::_M_init() -->
          <function-decl name='_M_init' mangled-name='_ZNSt10_List_baseIP19ProfileHandlerTokenSaIS1_EE7_M_initEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_list.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_List_base<ProfileHandlerToken*, std::allocator<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1154' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<ProfileHandlerToken*> -->
      <class-decl name='allocator&lt;ProfileHandlerToken*&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-1145'>
        <!-- class __gnu_cxx::new_allocator<ProfileHandlerToken*> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1124'/>
        <member-function access='private'>
          <!-- void std::allocator<ProfileHandlerToken*>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1164' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<ProfileHandlerToken*>::allocator(const std::allocator<ProfileHandlerToken*>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1164' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1147'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<ProfileHandlerToken*>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1164' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<ProfileHandlerToken*>::allocator<std::_List_node<ProfileHandlerToken*> >(const std::allocator<std::_List_node<ProfileHandlerToken*> >&) -->
          <function-decl name='allocator&lt;std::_List_node&lt;ProfileHandlerToken*&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1164' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_List_node<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1150'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_List_node<ProfileHandlerToken*> -->
      <class-decl name='_List_node&lt;ProfileHandlerToken*&gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1141'/>
      <!-- struct std::_List_const_iterator<ProfileHandlerToken*> -->
      <class-decl name='_List_const_iterator&lt;ProfileHandlerToken*&gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1170'/>
      <!-- class std::reverse_iterator<std::_List_iterator<ProfileHandlerToken*> > -->
      <class-decl name='reverse_iterator&lt;std::_List_iterator&lt;ProfileHandlerToken*&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-1171'/>
      <!-- class std::reverse_iterator<std::_List_const_iterator<ProfileHandlerToken*> > -->
      <class-decl name='reverse_iterator&lt;std::_List_const_iterator&lt;ProfileHandlerToken*&gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-1172'/>
    </namespace-decl>
    <!-- namespace __gnu_cxx -->
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> > -->
      <class-decl name='new_allocator&lt;std::_List_node&lt;ProfileHandlerToken*&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-1126'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::new_allocator(const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >&' -->
            <parameter type-id='type-id-1133'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_node<ProfileHandlerToken*>* __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::address(std::_List_node<ProfileHandlerToken*>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE7addressERS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1134' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1159'/>
            <!-- std::_List_node<ProfileHandlerToken*>* -->
            <return type-id='type-id-1160'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::_List_node<ProfileHandlerToken*>* __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::address(const std::_List_node<ProfileHandlerToken*>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE7addressERKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1134' is-artificial='yes'/>
            <!-- parameter of type 'const std::_List_node<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1143'/>
            <!-- const std::_List_node<ProfileHandlerToken*>* -->
            <return type-id='type-id-1144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_List_node<ProfileHandlerToken*>* __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::_List_node<ProfileHandlerToken*>* -->
            <return type-id='type-id-1160'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::deallocate(std::_List_node<ProfileHandlerToken*>*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE10deallocateEPS4_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1160'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1134' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::construct(std::_List_node<ProfileHandlerToken*>*, const std::_List_node<ProfileHandlerToken*>&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE9constructEPS4_RKS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1160'/>
            <!-- parameter of type 'const std::_List_node<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1143'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >::destroy(std::_List_node<ProfileHandlerToken*>*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP19ProfileHandlerTokenEE7destroyEPS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_List_node<ProfileHandlerToken*> >*' -->
            <parameter type-id='type-id-1127' is-artificial='yes'/>
            <!-- parameter of type 'std::_List_node<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1160'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<ProfileHandlerToken*> -->
      <class-decl name='new_allocator&lt;ProfileHandlerToken*&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-1124'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<ProfileHandlerToken*>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<ProfileHandlerToken*>::new_allocator(const __gnu_cxx::new_allocator<ProfileHandlerToken*>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<ProfileHandlerToken*>&' -->
            <parameter type-id='type-id-1130'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<ProfileHandlerToken*>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken** __gnu_cxx::new_allocator<ProfileHandlerToken*>::address(ProfileHandlerToken*&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE7addressERS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1131' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken*&' -->
            <parameter type-id='type-id-1122'/>
            <!-- ProfileHandlerToken** -->
            <return type-id='type-id-1123'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken* const* __gnu_cxx::new_allocator<ProfileHandlerToken*>::address(ProfileHandlerToken* const&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE7addressERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1131' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- ProfileHandlerToken* const* -->
            <return type-id='type-id-1121'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- ProfileHandlerToken** __gnu_cxx::new_allocator<ProfileHandlerToken*>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- ProfileHandlerToken** -->
            <return type-id='type-id-1123'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<ProfileHandlerToken*>::deallocate(ProfileHandlerToken**, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE10deallocateEPS2_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken**' -->
            <parameter type-id='type-id-1123'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<ProfileHandlerToken*>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1131' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<ProfileHandlerToken*>::construct(ProfileHandlerToken**, ProfileHandlerToken* const&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE9constructEPS2_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken**' -->
            <parameter type-id='type-id-1123'/>
            <!-- parameter of type 'ProfileHandlerToken* const&' -->
            <parameter type-id='type-id-1120'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<ProfileHandlerToken*>::destroy(ProfileHandlerToken**) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIP19ProfileHandlerTokenE7destroyEPS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<ProfileHandlerToken*>*' -->
            <parameter type-id='type-id-1125' is-artificial='yes'/>
            <!-- parameter of type 'ProfileHandlerToken**' -->
            <parameter type-id='type-id-1123'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- void ProfileHandlerGetState(ProfileHandlerState*) -->
    <function-decl name='ProfileHandlerGetState' mangled-name='ProfileHandlerGetState' filepath='src/profile-handler.cc' line='658' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfileHandlerGetState'>
      <!-- parameter of type 'ProfileHandlerState*' -->
      <parameter type-id='type-id-1115' name='state' filepath='src/profile-handler.cc' line='658' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfileHandlerReset() -->
    <function-decl name='ProfileHandlerReset' mangled-name='ProfileHandlerReset' filepath='src/profile-handler.cc' line='654' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfileHandlerReset'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfileHandlerUnregisterCallback(ProfileHandlerToken*) -->
    <function-decl name='ProfileHandlerUnregisterCallback' mangled-name='ProfileHandlerUnregisterCallback' filepath='src/profile-handler.cc' line='650' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfileHandlerUnregisterCallback'>
      <!-- parameter of type 'ProfileHandlerToken*' -->
      <parameter type-id='type-id-1114' name='token' filepath='src/profile-handler.cc' line='650' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- ProfileHandlerToken* ProfileHandlerRegisterCallback(ProfileHandlerCallback, void*) -->
    <function-decl name='ProfileHandlerRegisterCallback' mangled-name='ProfileHandlerRegisterCallback' filepath='src/profile-handler.cc' line='645' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfileHandlerRegisterCallback'>
      <!-- parameter of type 'typedef ProfileHandlerCallback' -->
      <parameter type-id='type-id-1101' name='callback' filepath='src/profile-handler.cc' line='646' column='1'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='callback_arg' filepath='src/profile-handler.cc' line='646' column='1'/>
      <!-- ProfileHandlerToken* -->
      <return type-id='type-id-1114'/>
    </function-decl>
    <!-- void ProfileHandlerRegisterThread() -->
    <function-decl name='ProfileHandlerRegisterThread' mangled-name='ProfileHandlerRegisterThread' filepath='src/profile-handler.cc' line='641' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfileHandlerRegisterThread'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- ProfileHandlerToken* -->
    <pointer-type-def type-id='type-id-1173' size-in-bits='64' id='type-id-1114'/>
    <!-- void (int, siginfo_t*, void*, void*) -->
    <function-type size-in-bits='64' id='type-id-1169'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'siginfo_t*' -->
      <parameter type-id='type-id-1116'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- siginfo_t* -->
    <pointer-type-def type-id='type-id-1174' size-in-bits='64' id='type-id-1116'/>
    <!-- struct ProfileHandlerToken -->
    <class-decl name='ProfileHandlerToken' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/profile-handler.cc' line='69' column='1' id='type-id-1173'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- ProfileHandlerCallback ProfileHandlerToken::callback -->
        <var-decl name='callback' type-id='type-id-1101' visibility='default' filepath='src/profile-handler.cc' line='77' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- void* ProfileHandlerToken::callback_arg -->
        <var-decl name='callback_arg' type-id='type-id-53' visibility='default' filepath='src/profile-handler.cc' line='79' column='1'/>
      </data-member>
      <member-function access='public' constructor='yes'>
        <!-- ProfileHandlerToken::ProfileHandlerToken(ProfileHandlerCallback, void*) -->
        <function-decl name='ProfileHandlerToken' filepath='src/profile-handler.cc' line='71' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileHandlerToken*' -->
          <parameter type-id='type-id-1114' is-artificial='yes'/>
          <!-- parameter of type 'typedef ProfileHandlerCallback' -->
          <parameter type-id='type-id-1101'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef siginfo siginfo_t -->
    <typedef-decl name='siginfo_t' type-id='type-id-1175' filepath='/usr/include/bits/siginfo.h' line='108' column='1' id='type-id-1174'/>
    <!-- struct siginfo -->
    <class-decl name='siginfo' size-in-bits='1024' is-struct='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='52' column='1' id='type-id-1175'>
      <member-type access='public'>
        <!-- union {int _pad[28]; struct {__pid_t si_pid; __uid_t si_uid;} _kill; struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer; struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt; struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld; struct {void* si_addr;} _sigfault; struct {long int si_band; int si_fd;} _sigpoll;} -->
        <union-decl name='__anonymous_union__' size-in-bits='896' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='59' column='1' id='type-id-1176'>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid;} -->
            <class-decl name='__anonymous_struct__' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='64' column='1' id='type-id-1177'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='65' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='66' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {int si_tid; int si_overrun; sigval_t si_sigval;} -->
            <class-decl name='__anonymous_struct__1' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='71' column='1' id='type-id-1179'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- int si_tid -->
                <var-decl name='si_tid' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='72' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- int si_overrun -->
                <var-decl name='si_overrun' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='73' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- sigval_t si_sigval -->
                <var-decl name='si_sigval' type-id='type-id-1180' visibility='default' filepath='/usr/include/bits/siginfo.h' line='74' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} -->
            <class-decl name='__anonymous_struct__2' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='79' column='1' id='type-id-1181'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='80' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='81' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- sigval_t si_sigval -->
                <var-decl name='si_sigval' type-id='type-id-1180' visibility='default' filepath='/usr/include/bits/siginfo.h' line='82' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} -->
            <class-decl name='__anonymous_struct__3' size-in-bits='256' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='87' column='1' id='type-id-1182'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='88' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='89' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- int si_status -->
                <var-decl name='si_status' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='90' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='128'>
                <!-- __clock_t si_utime -->
                <var-decl name='si_utime' type-id='type-id-1183' visibility='default' filepath='/usr/include/bits/siginfo.h' line='91' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='192'>
                <!-- __clock_t si_stime -->
                <var-decl name='si_stime' type-id='type-id-1183' visibility='default' filepath='/usr/include/bits/siginfo.h' line='92' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {void* si_addr;} -->
            <class-decl name='__anonymous_struct__4' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='97' column='1' id='type-id-1184'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- void* si_addr -->
                <var-decl name='si_addr' type-id='type-id-53' visibility='default' filepath='/usr/include/bits/siginfo.h' line='98' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {long int si_band; int si_fd;} -->
            <class-decl name='__anonymous_struct__5' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='103' column='1' id='type-id-1185'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- long int si_band -->
                <var-decl name='si_band' type-id='type-id-80' visibility='default' filepath='/usr/include/bits/siginfo.h' line='104' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- int si_fd -->
                <var-decl name='si_fd' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='105' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <data-member access='private'>
            <!-- int _pad[28] -->
            <var-decl name='_pad' type-id='type-id-1186' visibility='default' filepath='/usr/include/bits/siginfo.h' line='60' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid;} _kill -->
            <var-decl name='_kill' type-id='type-id-1177' visibility='default' filepath='/usr/include/bits/siginfo.h' line='67' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer -->
            <var-decl name='_timer' type-id='type-id-1179' visibility='default' filepath='/usr/include/bits/siginfo.h' line='75' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt -->
            <var-decl name='_rt' type-id='type-id-1181' visibility='default' filepath='/usr/include/bits/siginfo.h' line='83' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld -->
            <var-decl name='_sigchld' type-id='type-id-1182' visibility='default' filepath='/usr/include/bits/siginfo.h' line='93' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {void* si_addr;} _sigfault -->
            <var-decl name='_sigfault' type-id='type-id-1184' visibility='default' filepath='/usr/include/bits/siginfo.h' line='99' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {long int si_band; int si_fd;} _sigpoll -->
            <var-decl name='_sigpoll' type-id='type-id-1185' visibility='default' filepath='/usr/include/bits/siginfo.h' line='106' column='1'/>
          </data-member>
        </union-decl>
      </member-type>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int siginfo::si_signo -->
        <var-decl name='si_signo' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='53' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int siginfo::si_errno -->
        <var-decl name='si_errno' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='54' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int siginfo::si_code -->
        <var-decl name='si_code' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='56' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- union {int _pad[28]; struct {__pid_t si_pid; __uid_t si_uid;} _kill; struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer; struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt; struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld; struct {void* si_addr;} _sigfault; struct {long int si_band; int si_fd;} _sigpoll;} siginfo::_sifields -->
        <var-decl name='_sifields' type-id='type-id-1176' visibility='default' filepath='/usr/include/bits/siginfo.h' line='107' column='1'/>
      </data-member>
    </class-decl>
    <!-- int[28] -->
    <array-type-def dimensions='1' type-id='type-id-1' size-in-bits='896' id='type-id-1186'>
      <!-- <anonymous range>[28] -->
      <subrange length='28' type-id='type-id-5' id='type-id-1187'/>
    </array-type-def>
    <!-- typedef long int __clock_t -->
    <typedef-decl name='__clock_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='145' column='1' id='type-id-1183'/>
    <!-- typedef unsigned int __uid_t -->
    <typedef-decl name='__uid_t' type-id='type-id-59' filepath='/usr/include/bits/types.h' line='135' column='1' id='type-id-1178'/>
    <!-- typedef sigval sigval_t -->
    <typedef-decl name='sigval_t' type-id='type-id-1188' filepath='/usr/include/bits/siginfo.h' line='37' column='1' id='type-id-1180'/>
    <!-- union sigval -->
    <union-decl name='sigval' size-in-bits='64' visibility='default' filepath='/usr/include/bits/siginfo.h' line='34' column='1' id='type-id-1188'>
      <data-member access='private'>
        <!-- int sigval::sival_int -->
        <var-decl name='sival_int' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='35' column='1'/>
      </data-member>
      <data-member access='private'>
        <!-- void* sigval::sival_ptr -->
        <var-decl name='sival_ptr' type-id='type-id-53' visibility='default' filepath='/usr/include/bits/siginfo.h' line='36' column='1'/>
      </data-member>
    </union-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/profiledata.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/profiler.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- Slot[64] -->
    <array-type-def dimensions='1' type-id='type-id-1189' size-in-bits='4096' id='type-id-1190'>
      <!-- <anonymous range>[64] -->
      <subrange length='64' type-id='type-id-5' id='type-id-1191'/>
    </array-type-def>
    <!-- Entry[4] -->
    <array-type-def dimensions='1' type-id='type-id-1192' size-in-bits='16896' id='type-id-1193'>
      <!-- <anonymous range>[4] -->
      <subrange length='4' type-id='type-id-5' id='type-id-151'/>
    </array-type-def>
    <!-- char[1024] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='8192' id='type-id-1194'>
      <!-- <anonymous range>[1024] -->
      <subrange length='1024' type-id='type-id-5' id='type-id-1195'/>
    </array-type-def>
    <!-- int[28] -->
    <array-type-def dimensions='1' type-id='type-id-1' size-in-bits='896' id='type-id-1186'>
      <!-- <anonymous range>[28] -->
      <subrange length='28' type-id='type-id-5' id='type-id-1187'/>
    </array-type-def>
    <!-- class ProfileData -->
    <class-decl name='ProfileData' size-in-bits='448' visibility='default' filepath='src/profiledata.h' line='79' column='1' id='type-id-1196'>
      <member-type access='private'>
        <!-- class ProfileData::Options -->
        <class-decl name='Options' size-in-bits='32' visibility='default' filepath='src/profiledata.h' line='88' column='1' id='type-id-1197'>
          <data-member access='private' layout-offset-in-bits='0'>
            <!-- int ProfileData::Options::frequency_ -->
            <var-decl name='frequency_' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='101' column='1'/>
          </data-member>
          <member-function access='private' constructor='yes'>
            <!-- ProfileData::Options::Options() -->
            <function-decl name='Options' mangled-name='_ZN11ProfileData7OptionsC1Ev' filepath='src/profiledata.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData7OptionsC1Ev'>
              <!-- implicit parameter of type 'ProfileData::Options*' -->
              <parameter type-id='type-id-1198' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- int ProfileData::Options::frequency() -->
            <function-decl name='frequency' mangled-name='_ZNK11ProfileData7Options9frequencyEv' filepath='src/profiledata.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const ProfileData::Options*' -->
              <parameter type-id='type-id-1199' is-artificial='yes'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='private'>
            <!-- void ProfileData::Options::set_frequency(int) -->
            <function-decl name='set_frequency' mangled-name='_ZN11ProfileData7Options13set_frequencyEi' filepath='src/profiledata.h' line='96' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'ProfileData::Options*' -->
              <parameter type-id='type-id-1198' is-artificial='yes'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct ProfileData::State -->
        <class-decl name='State' size-in-bits='8384' is-struct='yes' visibility='default' filepath='src/profiledata.h' line='81' column='1' id='type-id-1200'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- bool ProfileData::State::enabled -->
            <var-decl name='enabled' type-id='type-id-55' visibility='default' filepath='src/profiledata.h' line='82' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- time_t ProfileData::State::start_time -->
            <var-decl name='start_time' type-id='type-id-1201' visibility='default' filepath='src/profiledata.h' line='83' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- char ProfileData::State::profile_name[1024] -->
            <var-decl name='profile_name' type-id='type-id-1194' visibility='default' filepath='src/profiledata.h' line='84' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='8320'>
            <!-- int ProfileData::State::samples_gathered -->
            <var-decl name='samples_gathered' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='85' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct ProfileData::Entry -->
        <class-decl name='Entry' size-in-bits='4224' is-struct='yes' visibility='default' filepath='src/profiledata.h' line='154' column='1' id='type-id-1192'>
          <member-type access='private'>
            <!-- typedef uintptr_t ProfileData::Entry::Slot -->
            <typedef-decl name='Slot' type-id='type-id-145' filepath='src/profiledata.h' line='151' column='1' id='type-id-1189'/>
          </member-type>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- ProfileData::Entry::Slot ProfileData::Entry::count -->
            <var-decl name='count' type-id='type-id-1189' visibility='default' filepath='src/profiledata.h' line='155' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- ProfileData::Entry::Slot ProfileData::Entry::depth -->
            <var-decl name='depth' type-id='type-id-1189' visibility='default' filepath='src/profiledata.h' line='156' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- ProfileData::Entry::Slot ProfileData::Entry::stack[64] -->
            <var-decl name='stack' type-id='type-id-1190' visibility='default' filepath='src/profiledata.h' line='157' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct ProfileData::Bucket -->
        <class-decl name='Bucket' size-in-bits='16896' is-struct='yes' visibility='default' filepath='src/profiledata.h' line='161' column='1' id='type-id-1202'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- ProfileData::Entry ProfileData::Bucket::entry[4] -->
            <var-decl name='entry' type-id='type-id-1193' visibility='default' filepath='src/profiledata.h' line='162' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const int ProfileData::kMaxStackDepth -->
        <var-decl name='kMaxStackDepth' type-id='type-id-134' mangled-name='_ZN11ProfileData14kMaxStackDepthE' visibility='default' filepath='src/profiledata.h' line='104' column='1' elf-symbol-id='_ZN11ProfileData14kMaxStackDepthE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int ProfileData::kAssociativity -->
        <var-decl name='kAssociativity' type-id='type-id-134' mangled-name='_ZN11ProfileData14kAssociativityE' visibility='default' filepath='src/profiledata.h' line='146' column='1' elf-symbol-id='_ZN11ProfileData14kAssociativityE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int ProfileData::kBuckets -->
        <var-decl name='kBuckets' type-id='type-id-134' mangled-name='_ZN11ProfileData8kBucketsE' visibility='default' filepath='src/profiledata.h' line='147' column='1' elf-symbol-id='_ZN11ProfileData8kBucketsE'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int ProfileData::kBufferLength -->
        <var-decl name='kBufferLength' type-id='type-id-134' mangled-name='_ZN11ProfileData13kBufferLengthE' visibility='default' filepath='src/profiledata.h' line='148' column='1' elf-symbol-id='_ZN11ProfileData13kBufferLengthE'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- ProfileData::Bucket* ProfileData::hash_ -->
        <var-decl name='hash_' type-id='type-id-1203' visibility='default' filepath='src/profiledata.h' line='165' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- ProfileData::Entry::Slot* ProfileData::evict_ -->
        <var-decl name='evict_' type-id='type-id-1204' visibility='default' filepath='src/profiledata.h' line='166' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- int ProfileData::num_evicted_ -->
        <var-decl name='num_evicted_' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='167' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='160'>
        <!-- int ProfileData::out_ -->
        <var-decl name='out_' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='168' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='192'>
        <!-- int ProfileData::count_ -->
        <var-decl name='count_' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='169' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='224'>
        <!-- int ProfileData::evictions_ -->
        <var-decl name='evictions_' type-id='type-id-1' visibility='default' filepath='src/profiledata.h' line='170' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- size_t ProfileData::total_bytes_ -->
        <var-decl name='total_bytes_' type-id='type-id-57' visibility='default' filepath='src/profiledata.h' line='171' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='320'>
        <!-- char* ProfileData::fname_ -->
        <var-decl name='fname_' type-id='type-id-113' visibility='default' filepath='src/profiledata.h' line='172' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='384'>
        <!-- time_t ProfileData::start_time_ -->
        <var-decl name='start_time_' type-id='type-id-1201' visibility='default' filepath='src/profiledata.h' line='173' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- ProfileData::ProfileData() -->
        <function-decl name='ProfileData' mangled-name='_ZN11ProfileDataC1Ev' filepath='src/profiledata.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileDataC1Ev'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- ProfileData::~ProfileData(int) -->
        <function-decl name='~ProfileData' mangled-name='_ZN11ProfileDataD1Ev' filepath='src/profiledata.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileDataD1Ev'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProfileData::Start(const char*, const ProfileData::Options&) -->
        <function-decl name='Start' mangled-name='_ZN11ProfileData5StartEPKcRKNS_7OptionsE' filepath='src/profiledata.h' line='116' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData5StartEPKcRKNS_7OptionsE'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'const ProfileData::Options&' -->
          <parameter type-id='type-id-1206'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::Stop() -->
        <function-decl name='Stop' mangled-name='_ZN11ProfileData4StopEv' filepath='src/profiledata.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData4StopEv'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::Reset() -->
        <function-decl name='Reset' mangled-name='_ZN11ProfileData5ResetEv' filepath='src/profiledata.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData5ResetEv'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::Add(int, void* const*) -->
        <function-decl name='Add' mangled-name='_ZN11ProfileData3AddEiPKPKv' filepath='src/profiledata.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData3AddEiPKPKv'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void* const*' -->
          <parameter type-id='type-id-173'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::FlushTable() -->
        <function-decl name='FlushTable' mangled-name='_ZN11ProfileData10FlushTableEv' filepath='src/profiledata.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData10FlushTableEv'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool ProfileData::enabled() -->
        <function-decl name='enabled' mangled-name='_ZNK11ProfileData7enabledEv' filepath='src/profiledata.h' line='140' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const ProfileData*' -->
          <parameter type-id='type-id-1207' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::GetCurrentState(ProfileData::State*) -->
        <function-decl name='GetCurrentState' mangled-name='_ZNK11ProfileData15GetCurrentStateEPNS_5StateE' filepath='src/profiledata.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK11ProfileData15GetCurrentStateEPNS_5StateE'>
          <!-- implicit parameter of type 'const ProfileData*' -->
          <parameter type-id='type-id-1207' is-artificial='yes'/>
          <!-- parameter of type 'ProfileData::State*' -->
          <parameter type-id='type-id-1208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::Evict(const ProfileData::Entry&) -->
        <function-decl name='Evict' mangled-name='_ZN11ProfileData5EvictERKNS_5EntryE' filepath='src/profiledata.h' line='176' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData5EvictERKNS_5EntryE'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- parameter of type 'const ProfileData::Entry&' -->
          <parameter type-id='type-id-1209'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::FlushEvicted() -->
        <function-decl name='FlushEvicted' mangled-name='_ZN11ProfileData12FlushEvictedEv' filepath='src/profiledata.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11ProfileData12FlushEvictedEv'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- ProfileData::ProfileData(const ProfileData&) -->
        <function-decl name='ProfileData' filepath='src/profiledata.h' line='181' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- parameter of type 'const ProfileData&' -->
          <parameter type-id='type-id-1210'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void ProfileData::operator=(const ProfileData&) -->
        <function-decl name='operator=' mangled-name='_ZN11ProfileDataaSERKS_' filepath='src/profiledata.h' line='181' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileData*' -->
          <parameter type-id='type-id-1205' is-artificial='yes'/>
          <!-- parameter of type 'const ProfileData&' -->
          <parameter type-id='type-id-1210'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct ProfileHandlerToken -->
    <class-decl name='ProfileHandlerToken' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/profile-handler.cc' line='69' column='1' id='type-id-1173'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- ProfileHandlerCallback ProfileHandlerToken::callback -->
        <var-decl name='callback' type-id='type-id-1101' visibility='default' filepath='src/profile-handler.cc' line='77' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- void* ProfileHandlerToken::callback_arg -->
        <var-decl name='callback_arg' type-id='type-id-53' visibility='default' filepath='src/profile-handler.cc' line='79' column='1'/>
      </data-member>
      <member-function access='public' constructor='yes'>
        <!-- ProfileHandlerToken::ProfileHandlerToken(ProfileHandlerCallback, void*) -->
        <function-decl name='ProfileHandlerToken' filepath='src/profile-handler.cc' line='71' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'ProfileHandlerToken*' -->
          <parameter type-id='type-id-1114' is-artificial='yes'/>
          <!-- parameter of type 'typedef ProfileHandlerCallback' -->
          <parameter type-id='type-id-1101'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef __time_t time_t -->
    <typedef-decl name='time_t' type-id='type-id-1211' filepath='/usr/include/time.h' line='76' column='1' id='type-id-1201'/>
    <!-- typedef long int __time_t -->
    <typedef-decl name='__time_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='149' column='1' id='type-id-1211'/>
    <!-- struct siginfo -->
    <class-decl name='siginfo' size-in-bits='1024' is-struct='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='52' column='1' id='type-id-1175'>
      <member-type access='public'>
        <!-- union {int _pad[28]; struct {__pid_t si_pid; __uid_t si_uid;} _kill; struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer; struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt; struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld; struct {void* si_addr;} _sigfault; struct {long int si_band; int si_fd;} _sigpoll;} -->
        <union-decl name='__anonymous_union__' size-in-bits='896' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='59' column='1' id='type-id-1176'>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid;} -->
            <class-decl name='__anonymous_struct__' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='64' column='1' id='type-id-1177'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='65' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='66' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {int si_tid; int si_overrun; sigval_t si_sigval;} -->
            <class-decl name='__anonymous_struct__1' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='71' column='1' id='type-id-1179'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- int si_tid -->
                <var-decl name='si_tid' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='72' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- int si_overrun -->
                <var-decl name='si_overrun' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='73' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- sigval_t si_sigval -->
                <var-decl name='si_sigval' type-id='type-id-1180' visibility='default' filepath='/usr/include/bits/siginfo.h' line='74' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} -->
            <class-decl name='__anonymous_struct__2' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='79' column='1' id='type-id-1181'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='80' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='81' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- sigval_t si_sigval -->
                <var-decl name='si_sigval' type-id='type-id-1180' visibility='default' filepath='/usr/include/bits/siginfo.h' line='82' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} -->
            <class-decl name='__anonymous_struct__3' size-in-bits='256' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='87' column='1' id='type-id-1182'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- __pid_t si_pid -->
                <var-decl name='si_pid' type-id='type-id-63' visibility='default' filepath='/usr/include/bits/siginfo.h' line='88' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='32'>
                <!-- __uid_t si_uid -->
                <var-decl name='si_uid' type-id='type-id-1178' visibility='default' filepath='/usr/include/bits/siginfo.h' line='89' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- int si_status -->
                <var-decl name='si_status' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='90' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='128'>
                <!-- __clock_t si_utime -->
                <var-decl name='si_utime' type-id='type-id-1183' visibility='default' filepath='/usr/include/bits/siginfo.h' line='91' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='192'>
                <!-- __clock_t si_stime -->
                <var-decl name='si_stime' type-id='type-id-1183' visibility='default' filepath='/usr/include/bits/siginfo.h' line='92' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {void* si_addr;} -->
            <class-decl name='__anonymous_struct__4' size-in-bits='64' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='97' column='1' id='type-id-1184'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- void* si_addr -->
                <var-decl name='si_addr' type-id='type-id-53' visibility='default' filepath='/usr/include/bits/siginfo.h' line='98' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <member-type access='private'>
            <!-- struct {long int si_band; int si_fd;} -->
            <class-decl name='__anonymous_struct__5' size-in-bits='128' is-struct='yes' is-anonymous='yes' visibility='default' filepath='/usr/include/bits/siginfo.h' line='103' column='1' id='type-id-1185'>
              <data-member access='public' layout-offset-in-bits='0'>
                <!-- long int si_band -->
                <var-decl name='si_band' type-id='type-id-80' visibility='default' filepath='/usr/include/bits/siginfo.h' line='104' column='1'/>
              </data-member>
              <data-member access='public' layout-offset-in-bits='64'>
                <!-- int si_fd -->
                <var-decl name='si_fd' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='105' column='1'/>
              </data-member>
            </class-decl>
          </member-type>
          <data-member access='private'>
            <!-- int _pad[28] -->
            <var-decl name='_pad' type-id='type-id-1186' visibility='default' filepath='/usr/include/bits/siginfo.h' line='60' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid;} _kill -->
            <var-decl name='_kill' type-id='type-id-1177' visibility='default' filepath='/usr/include/bits/siginfo.h' line='67' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer -->
            <var-decl name='_timer' type-id='type-id-1179' visibility='default' filepath='/usr/include/bits/siginfo.h' line='75' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt -->
            <var-decl name='_rt' type-id='type-id-1181' visibility='default' filepath='/usr/include/bits/siginfo.h' line='83' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld -->
            <var-decl name='_sigchld' type-id='type-id-1182' visibility='default' filepath='/usr/include/bits/siginfo.h' line='93' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {void* si_addr;} _sigfault -->
            <var-decl name='_sigfault' type-id='type-id-1184' visibility='default' filepath='/usr/include/bits/siginfo.h' line='99' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- struct {long int si_band; int si_fd;} _sigpoll -->
            <var-decl name='_sigpoll' type-id='type-id-1185' visibility='default' filepath='/usr/include/bits/siginfo.h' line='106' column='1'/>
          </data-member>
        </union-decl>
      </member-type>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int siginfo::si_signo -->
        <var-decl name='si_signo' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='53' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int siginfo::si_errno -->
        <var-decl name='si_errno' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='54' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int siginfo::si_code -->
        <var-decl name='si_code' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='56' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- union {int _pad[28]; struct {__pid_t si_pid; __uid_t si_uid;} _kill; struct {int si_tid; int si_overrun; sigval_t si_sigval;} _timer; struct {__pid_t si_pid; __uid_t si_uid; sigval_t si_sigval;} _rt; struct {__pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime;} _sigchld; struct {void* si_addr;} _sigfault; struct {long int si_band; int si_fd;} _sigpoll;} siginfo::_sifields -->
        <var-decl name='_sifields' type-id='type-id-1176' visibility='default' filepath='/usr/include/bits/siginfo.h' line='107' column='1'/>
      </data-member>
    </class-decl>
    <!-- class CpuProfiler -->
    <class-decl name='CpuProfiler' size-in-bits='704' visibility='default' filepath='src/profiler.cc' line='89' column='1' id='type-id-1212'>
      <data-member access='private' static='yes'>
        <!-- static CpuProfiler CpuProfiler::instance_ -->
        <var-decl name='instance_' type-id='type-id-1212' mangled-name='_ZN11CpuProfiler9instance_E' visibility='default' filepath='src/profiler.cc' line='107' column='1' elf-symbol-id='_ZN11CpuProfiler9instance_E'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- SpinLock CpuProfiler::lock_ -->
        <var-decl name='lock_' type-id='type-id-82' visibility='default' filepath='src/profiler.cc' line='119' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- ProfileData CpuProfiler::collector_ -->
        <var-decl name='collector_' type-id='type-id-1196' visibility='default' filepath='src/profiler.cc' line='120' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='512'>
        <!-- int (void*)* CpuProfiler::filter_ -->
        <var-decl name='filter_' type-id='type-id-1213' visibility='default' filepath='src/profiler.cc' line='125' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='576'>
        <!-- void* CpuProfiler::filter_arg_ -->
        <var-decl name='filter_arg_' type-id='type-id-53' visibility='default' filepath='src/profiler.cc' line='126' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='640'>
        <!-- ProfileHandlerToken* CpuProfiler::prof_handler_token_ -->
        <var-decl name='prof_handler_token_' type-id='type-id-1114' visibility='default' filepath='src/profiler.cc' line='130' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- CpuProfiler::CpuProfiler() -->
        <function-decl name='CpuProfiler' mangled-name='_ZN11CpuProfilerC1Ev' filepath='src/profiler.cc' line='91' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfilerC1Ev'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- CpuProfiler::~CpuProfiler(int) -->
        <function-decl name='~CpuProfiler' mangled-name='_ZN11CpuProfilerD1Ev' filepath='src/profiler.cc' line='92' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfilerD1Ev'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool CpuProfiler::Start(const char*, const ProfilerOptions*) -->
        <function-decl name='Start' mangled-name='_ZN11CpuProfiler5StartEPKcPK15ProfilerOptions' filepath='src/profiler.cc' line='95' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler5StartEPKcPK15ProfilerOptions'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'const ProfilerOptions*' -->
          <parameter type-id='type-id-1215'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void CpuProfiler::Stop() -->
        <function-decl name='Stop' mangled-name='_ZN11CpuProfiler4StopEv' filepath='src/profiler.cc' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler4StopEv'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void CpuProfiler::FlushTable() -->
        <function-decl name='FlushTable' mangled-name='_ZN11CpuProfiler10FlushTableEv' filepath='src/profiler.cc' line='101' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler10FlushTableEv'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool CpuProfiler::Enabled() -->
        <function-decl name='Enabled' mangled-name='_ZN11CpuProfiler7EnabledEv' filepath='src/profiler.cc' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler7EnabledEv'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void CpuProfiler::GetCurrentState(ProfilerState*) -->
        <function-decl name='GetCurrentState' mangled-name='_ZN11CpuProfiler15GetCurrentStateEP13ProfilerState' filepath='src/profiler.cc' line='105' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler15GetCurrentStateEP13ProfilerState'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- parameter of type 'ProfilerState*' -->
          <parameter type-id='type-id-1216'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void CpuProfiler::EnableHandler() -->
        <function-decl name='EnableHandler' mangled-name='_ZN11CpuProfiler13EnableHandlerEv' filepath='src/profiler.cc' line='133' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler13EnableHandlerEv'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void CpuProfiler::DisableHandler() -->
        <function-decl name='DisableHandler' mangled-name='_ZN11CpuProfiler14DisableHandlerEv' filepath='src/profiler.cc' line='136' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler14DisableHandlerEv'>
          <!-- implicit parameter of type 'CpuProfiler*' -->
          <parameter type-id='type-id-1214' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void CpuProfiler::prof_handler(siginfo_t*, void*, void*) -->
        <function-decl name='prof_handler' mangled-name='_ZN11CpuProfiler12prof_handlerEiP7siginfoPvS2_' filepath='src/profiler.cc' line='139' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11CpuProfiler12prof_handlerEiP7siginfoPvS2_'>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'siginfo_t*' -->
          <parameter type-id='type-id-1116'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct ProfilerOptions -->
    <class-decl name='ProfilerOptions' size-in-bits='128' is-struct='yes' visibility='default' filepath='./src/gperftools/profiler.h' line='89' column='1' id='type-id-1217'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int (void*)* ProfilerOptions::filter_in_thread -->
        <var-decl name='filter_in_thread' type-id='type-id-1213' visibility='default' filepath='./src/gperftools/profiler.h' line='108' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- void* ProfilerOptions::filter_in_thread_arg -->
        <var-decl name='filter_in_thread_arg' type-id='type-id-53' visibility='default' filepath='./src/gperftools/profiler.h' line='109' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct ProfilerState -->
    <class-decl name='ProfilerState' size-in-bits='8384' is-struct='yes' visibility='default' filepath='./src/gperftools/profiler.h' line='157' column='1' id='type-id-1218'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int ProfilerState::enabled -->
        <var-decl name='enabled' type-id='type-id-1' visibility='default' filepath='./src/gperftools/profiler.h' line='158' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- time_t ProfilerState::start_time -->
        <var-decl name='start_time' type-id='type-id-1201' visibility='default' filepath='./src/gperftools/profiler.h' line='159' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- char ProfilerState::profile_name[1024] -->
        <var-decl name='profile_name' type-id='type-id-1194' visibility='default' filepath='./src/gperftools/profiler.h' line='160' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='8320'>
        <!-- int ProfilerState::samples_gathered -->
        <var-decl name='samples_gathered' type-id='type-id-1' visibility='default' filepath='./src/gperftools/profiler.h' line='161' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef siginfo siginfo_t -->
    <typedef-decl name='siginfo_t' type-id='type-id-1175' filepath='/usr/include/bits/siginfo.h' line='108' column='1' id='type-id-1174'/>
    <!-- typedef unsigned int __uid_t -->
    <typedef-decl name='__uid_t' type-id='type-id-59' filepath='/usr/include/bits/types.h' line='135' column='1' id='type-id-1178'/>
    <!-- typedef sigval sigval_t -->
    <typedef-decl name='sigval_t' type-id='type-id-1188' filepath='/usr/include/bits/siginfo.h' line='37' column='1' id='type-id-1180'/>
    <!-- union sigval -->
    <union-decl name='sigval' size-in-bits='64' visibility='default' filepath='/usr/include/bits/siginfo.h' line='34' column='1' id='type-id-1188'>
      <data-member access='private'>
        <!-- int sigval::sival_int -->
        <var-decl name='sival_int' type-id='type-id-1' visibility='default' filepath='/usr/include/bits/siginfo.h' line='35' column='1'/>
      </data-member>
      <data-member access='private'>
        <!-- void* sigval::sival_ptr -->
        <var-decl name='sival_ptr' type-id='type-id-53' visibility='default' filepath='/usr/include/bits/siginfo.h' line='36' column='1'/>
      </data-member>
    </union-decl>
    <!-- typedef long int __clock_t -->
    <typedef-decl name='__clock_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='145' column='1' id='type-id-1183'/>
    <!-- CpuProfiler* -->
    <pointer-type-def type-id='type-id-1212' size-in-bits='64' id='type-id-1214'/>
    <!-- ProfileData* -->
    <pointer-type-def type-id='type-id-1196' size-in-bits='64' id='type-id-1205'/>
    <!-- ProfileData::Bucket* -->
    <pointer-type-def type-id='type-id-1202' size-in-bits='64' id='type-id-1203'/>
    <!-- ProfileData::Entry::Slot* -->
    <pointer-type-def type-id='type-id-1189' size-in-bits='64' id='type-id-1204'/>
    <!-- ProfileData::Options* -->
    <pointer-type-def type-id='type-id-1197' size-in-bits='64' id='type-id-1198'/>
    <!-- ProfileData::State* -->
    <pointer-type-def type-id='type-id-1200' size-in-bits='64' id='type-id-1208'/>
    <!-- ProfileHandlerToken* -->
    <pointer-type-def type-id='type-id-1173' size-in-bits='64' id='type-id-1114'/>
    <!-- ProfilerState* -->
    <pointer-type-def type-id='type-id-1218' size-in-bits='64' id='type-id-1216'/>
    <!-- const ProfileData -->
    <qualified-type-def type-id='type-id-1196' const='yes' id='type-id-1219'/>
    <!-- const ProfileData& -->
    <reference-type-def kind='lvalue' type-id='type-id-1219' size-in-bits='64' id='type-id-1210'/>
    <!-- const ProfileData* -->
    <pointer-type-def type-id='type-id-1219' size-in-bits='64' id='type-id-1207'/>
    <!-- const ProfileData::Entry -->
    <qualified-type-def type-id='type-id-1192' const='yes' id='type-id-1220'/>
    <!-- const ProfileData::Entry& -->
    <reference-type-def kind='lvalue' type-id='type-id-1220' size-in-bits='64' id='type-id-1209'/>
    <!-- const ProfileData::Options -->
    <qualified-type-def type-id='type-id-1197' const='yes' id='type-id-1221'/>
    <!-- const ProfileData::Options& -->
    <reference-type-def kind='lvalue' type-id='type-id-1221' size-in-bits='64' id='type-id-1206'/>
    <!-- const ProfileData::Options* -->
    <pointer-type-def type-id='type-id-1221' size-in-bits='64' id='type-id-1199'/>
    <!-- const ProfilerOptions -->
    <qualified-type-def type-id='type-id-1217' const='yes' id='type-id-1222'/>
    <!-- const ProfilerOptions* -->
    <pointer-type-def type-id='type-id-1222' size-in-bits='64' id='type-id-1215'/>
    <!-- int (void*)* -->
    <pointer-type-def type-id='type-id-1223' size-in-bits='64' id='type-id-1213'/>
    <!-- siginfo_t* -->
    <pointer-type-def type-id='type-id-1174' size-in-bits='64' id='type-id-1116'/>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_cpu_profiler_unittest -->
      <var-decl name='FLAGS_cpu_profiler_unittest' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead27FLAGS_cpu_profiler_unittestE' visibility='default' filepath='src/profiler.cc' line='74' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead27FLAGS_cpu_profiler_unittestE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nocpu_profiler_unittest -->
      <var-decl name='FLAGS_nocpu_profiler_unittest' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_nocpu_profiler_unittestE' visibility='default' filepath='src/profiler.cc' line='78' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead29FLAGS_nocpu_profiler_unittestE'/>
    </namespace-decl>
    <!-- void ProfilerEnable() -->
    <function-decl name='ProfilerEnable' mangled-name='ProfilerEnable' filepath='src/profiler.cc' line='430' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerEnable'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfilerDisable() -->
    <function-decl name='ProfilerDisable' mangled-name='ProfilerDisable' filepath='src/profiler.cc' line='431' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerDisable'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfilerRegisterThread() -->
    <function-decl name='ProfilerRegisterThread' mangled-name='ProfilerRegisterThread' filepath='src/profiler.cc' line='378' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerRegisterThread'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int ProfilingIsEnabledForAllThreads() -->
    <function-decl name='ProfilingIsEnabledForAllThreads' mangled-name='ProfilingIsEnabledForAllThreads' filepath='src/profiler.cc' line='386' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilingIsEnabledForAllThreads'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void ProfilerStop() -->
    <function-decl name='ProfilerStop' mangled-name='ProfilerStop' filepath='src/profiler.cc' line='399' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerStop'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfilerFlush() -->
    <function-decl name='ProfilerFlush' mangled-name='ProfilerFlush' filepath='src/profiler.cc' line='382' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerFlush'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void ProfilerGetCurrentState(ProfilerState*) -->
    <function-decl name='ProfilerGetCurrentState' mangled-name='ProfilerGetCurrentState' filepath='src/profiler.cc' line='403' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerGetCurrentState'>
      <!-- parameter of type 'ProfilerState*' -->
      <parameter type-id='type-id-1216' name='state' filepath='src/profiler.cc' line='404' column='1'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int ProfilerStartWithOptions(const char*, const ProfilerOptions*) -->
    <function-decl name='ProfilerStartWithOptions' mangled-name='ProfilerStartWithOptions' filepath='src/profiler.cc' line='394' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerStartWithOptions'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52' name='fname' filepath='src/profiler.cc' line='395' column='1'/>
      <!-- parameter of type 'const ProfilerOptions*' -->
      <parameter type-id='type-id-1215' name='options' filepath='src/profiler.cc' line='395' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int ProfilerStart(const char*) -->
    <function-decl name='ProfilerStart' mangled-name='ProfilerStart' filepath='src/profiler.cc' line='390' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='ProfilerStart'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int (void*) -->
    <function-type size-in-bits='64' id='type-id-1223'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-type>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/raw_printer.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- base::RawPrinter* -->
    <pointer-type-def type-id='type-id-1224' size-in-bits='64' id='type-id-1225'/>
    <!-- const base::RawPrinter -->
    <qualified-type-def type-id='type-id-1224' const='yes' id='type-id-1226'/>
    <!-- const base::RawPrinter& -->
    <reference-type-def kind='lvalue' type-id='type-id-1226' size-in-bits='64' id='type-id-1227'/>
    <!-- const base::RawPrinter* -->
    <pointer-type-def type-id='type-id-1226' size-in-bits='64' id='type-id-1228'/>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- class base::RawPrinter -->
      <class-decl name='RawPrinter' size-in-bits='192' visibility='default' filepath='src/raw_printer.h' line='51' column='1' id='type-id-1224'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* base::RawPrinter::base_ -->
          <var-decl name='base_' type-id='type-id-113' visibility='default' filepath='src/raw_printer.h' line='81' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- char* base::RawPrinter::ptr_ -->
          <var-decl name='ptr_' type-id='type-id-113' visibility='default' filepath='src/raw_printer.h' line='82' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- char* base::RawPrinter::limit_ -->
          <var-decl name='limit_' type-id='type-id-113' visibility='default' filepath='src/raw_printer.h' line='83' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- base::RawPrinter::RawPrinter(char*, int) -->
          <function-decl name='RawPrinter' mangled-name='_ZN4base10RawPrinterC1EPci' filepath='src/raw_printer.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base10RawPrinterC1EPci'>
            <!-- implicit parameter of type 'base::RawPrinter*' -->
            <parameter type-id='type-id-1225' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int base::RawPrinter::length() -->
          <function-decl name='length' mangled-name='_ZNK4base10RawPrinter6lengthEv' filepath='src/raw_printer.h' line='60' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::RawPrinter*' -->
            <parameter type-id='type-id-1228' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int base::RawPrinter::space_left() -->
          <function-decl name='space_left' mangled-name='_ZNK4base10RawPrinter10space_leftEv' filepath='src/raw_printer.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const base::RawPrinter*' -->
            <parameter type-id='type-id-1228' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void base::RawPrinter::Printf(const char*, ...) -->
          <function-decl name='Printf' mangled-name='_ZN4base10RawPrinter6PrintfEPKcz' filepath='src/raw_printer.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base10RawPrinter6PrintfEPKcz'>
            <!-- implicit parameter of type 'base::RawPrinter*' -->
            <parameter type-id='type-id-1225' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <parameter is-variadic='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- base::RawPrinter::RawPrinter(const base::RawPrinter&) -->
          <function-decl name='RawPrinter' filepath='src/raw_printer.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'base::RawPrinter*' -->
            <parameter type-id='type-id-1225' is-artificial='yes'/>
            <!-- parameter of type 'const base::RawPrinter&' -->
            <parameter type-id='type-id-1227'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void base::RawPrinter::operator=(const base::RawPrinter&) -->
          <function-decl name='operator=' mangled-name='_ZN4base10RawPrinteraSERKS0_' filepath='src/raw_printer.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'base::RawPrinter*' -->
            <parameter type-id='type-id-1225' is-artificial='yes'/>
            <!-- parameter of type 'const base::RawPrinter&' -->
            <parameter type-id='type-id-1227'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/sampler.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- const double& std::min<double>(const double&, const double&) -->
      <function-decl name='min&lt;double&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const double&' -->
        <parameter type-id='type-id-1229'/>
        <!-- parameter of type 'const double&' -->
        <parameter type-id='type-id-1229'/>
        <!-- const double& -->
        <return type-id='type-id-1229'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_sample_parameter -->
      <var-decl name='FLAGS_tcmalloc_sample_parameter' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead31FLAGS_tcmalloc_sample_parameterE' visibility='default' filepath='src/sampler.cc' line='52' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead31FLAGS_tcmalloc_sample_parameterE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_sample_parameter -->
      <var-decl name='FLAGS_notcmalloc_sample_parameter' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_notcmalloc_sample_parameterE' visibility='default' filepath='src/sampler.cc' line='55' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead33FLAGS_notcmalloc_sample_parameterE'/>
    </namespace-decl>
    <!-- const double& -->
    <reference-type-def kind='lvalue' type-id='type-id-1230' size-in-bits='64' id='type-id-1229'/>
    <!-- const double -->
    <qualified-type-def type-id='type-id-2' const='yes' id='type-id-1230'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/span.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- void tcmalloc::DeleteSpan(tcmalloc::Span*) -->
      <function-decl name='DeleteSpan' mangled-name='_ZN8tcmalloc10DeleteSpanEPNS_4SpanE' filepath='src/span.cc' line='65' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc10DeleteSpanEPNS_4SpanE'>
        <!-- parameter of type 'tcmalloc::Span*' -->
        <parameter type-id='type-id-144'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void tcmalloc::DLL_Init(tcmalloc::Span*) -->
      <function-decl name='DLL_Init' mangled-name='_ZN8tcmalloc8DLL_InitEPNS_4SpanE' filepath='src/span.cc' line='73' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8DLL_InitEPNS_4SpanE'>
        <!-- parameter of type 'tcmalloc::Span*' -->
        <parameter type-id='type-id-144'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void tcmalloc::DLL_Remove(tcmalloc::Span*) -->
      <function-decl name='DLL_Remove' mangled-name='_ZN8tcmalloc10DLL_RemoveEPNS_4SpanE' filepath='src/span.cc' line='78' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc10DLL_RemoveEPNS_4SpanE'>
        <!-- parameter of type 'tcmalloc::Span*' -->
        <parameter type-id='type-id-144'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- int tcmalloc::DLL_Length(const tcmalloc::Span*) -->
      <function-decl name='DLL_Length' mangled-name='_ZN8tcmalloc10DLL_LengthEPKNS_4SpanE' filepath='src/span.cc' line='85' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc10DLL_LengthEPKNS_4SpanE'>
        <!-- parameter of type 'const tcmalloc::Span*' -->
        <parameter type-id='type-id-140'/>
        <!-- int -->
        <return type-id='type-id-1'/>
      </function-decl>
      <!-- void tcmalloc::DLL_Prepend(tcmalloc::Span*, tcmalloc::Span*) -->
      <function-decl name='DLL_Prepend' mangled-name='_ZN8tcmalloc11DLL_PrependEPNS_4SpanES1_' filepath='src/span.cc' line='93' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11DLL_PrependEPNS_4SpanES1_'>
        <!-- parameter of type 'tcmalloc::Span*' -->
        <parameter type-id='type-id-144'/>
        <!-- parameter of type 'tcmalloc::Span*' -->
        <parameter type-id='type-id-144'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- tcmalloc::Span* tcmalloc::NewSpan(PageID, Length) -->
      <function-decl name='NewSpan' mangled-name='_ZN8tcmalloc7NewSpanEmm' filepath='src/span.cc' line='54' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7NewSpanEmm'>
        <!-- parameter of type 'typedef PageID' -->
        <parameter type-id='type-id-142'/>
        <!-- parameter of type 'typedef Length' -->
        <parameter type-id='type-id-143'/>
        <!-- tcmalloc::Span* -->
        <return type-id='type-id-144'/>
      </function-decl>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/stack_trace_table.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket> -->
    <qualified-type-def type-id='type-id-1231' const='yes' id='type-id-1232'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>* -->
    <pointer-type-def type-id='type-id-1232' size-in-bits='64' id='type-id-1233'/>
    <!-- const tcmalloc::StackTrace -->
    <qualified-type-def type-id='type-id-1234' const='yes' id='type-id-1235'/>
    <!-- const tcmalloc::StackTrace& -->
    <reference-type-def kind='lvalue' type-id='type-id-1235' size-in-bits='64' id='type-id-1236'/>
    <!-- const tcmalloc::StackTraceTable -->
    <qualified-type-def type-id='type-id-1237' const='yes' id='type-id-1238'/>
    <!-- const tcmalloc::StackTraceTable* -->
    <pointer-type-def type-id='type-id-1238' size-in-bits='64' id='type-id-1239'/>
    <!-- const tcmalloc::StackTraceTable::Bucket -->
    <qualified-type-def type-id='type-id-1240' const='yes' id='type-id-1241'/>
    <!-- const tcmalloc::StackTraceTable::Bucket* -->
    <pointer-type-def type-id='type-id-1241' size-in-bits='64' id='type-id-1242'/>
    <!-- tcmalloc::StackTraceTable* -->
    <pointer-type-def type-id='type-id-1237' size-in-bits='64' id='type-id-1243'/>
    <!-- tcmalloc::StackTraceTable::Bucket* -->
    <pointer-type-def type-id='type-id-1240' size-in-bits='64' id='type-id-1244'/>
    <!-- tcmalloc::StackTraceTable::Bucket** -->
    <pointer-type-def type-id='type-id-1244' size-in-bits='64' id='type-id-1245'/>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- class tcmalloc::StackTraceTable -->
      <class-decl name='StackTraceTable' size-in-bits='192' visibility='default' filepath='src/stack_trace_table.h' line='47' column='1' id='type-id-1237'>
        <member-type access='private'>
          <!-- struct tcmalloc::StackTraceTable::Bucket -->
          <class-decl name='Bucket' size-in-bits='2304' is-struct='yes' visibility='default' filepath='src/stack_trace_table.h' line='65' column='1' id='type-id-1240'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- uintptr_t tcmalloc::StackTraceTable::Bucket::hash -->
              <var-decl name='hash' type-id='type-id-145' visibility='default' filepath='src/stack_trace_table.h' line='67' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- tcmalloc::StackTrace tcmalloc::StackTraceTable::Bucket::trace -->
              <var-decl name='trace' type-id='type-id-1234' visibility='default' filepath='src/stack_trace_table.h' line='68' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='2176'>
              <!-- int tcmalloc::StackTraceTable::Bucket::count -->
              <var-decl name='count' type-id='type-id-1' visibility='default' filepath='src/stack_trace_table.h' line='71' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='2240'>
              <!-- tcmalloc::StackTraceTable::Bucket* tcmalloc::StackTraceTable::Bucket::next -->
              <var-decl name='next' type-id='type-id-1244' visibility='default' filepath='src/stack_trace_table.h' line='72' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- bool tcmalloc::StackTraceTable::Bucket::KeyEqual(uintptr_t, const tcmalloc::StackTrace&) -->
              <function-decl name='KeyEqual' mangled-name='_ZNK8tcmalloc15StackTraceTable6Bucket8KeyEqualEmRKNS_10StackTraceE' filepath='src/stack_trace_table.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK8tcmalloc15StackTraceTable6Bucket8KeyEqualEmRKNS_10StackTraceE'>
                <!-- implicit parameter of type 'const tcmalloc::StackTraceTable::Bucket*' -->
                <parameter type-id='type-id-1242' is-artificial='yes'/>
                <!-- parameter of type 'typedef uintptr_t' -->
                <parameter type-id='type-id-145'/>
                <!-- parameter of type 'const tcmalloc::StackTrace&' -->
                <parameter type-id='type-id-1236'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::StackTraceTable::kHashTableSize -->
          <var-decl name='kHashTableSize' type-id='type-id-134' visibility='default' filepath='src/stack_trace_table.h' line='82' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- bool tcmalloc::StackTraceTable::error_ -->
          <var-decl name='error_' type-id='type-id-55' visibility='default' filepath='src/stack_trace_table.h' line='84' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='32'>
          <!-- int tcmalloc::StackTraceTable::depth_total_ -->
          <var-decl name='depth_total_' type-id='type-id-1' visibility='default' filepath='src/stack_trace_table.h' line='85' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- int tcmalloc::StackTraceTable::bucket_total_ -->
          <var-decl name='bucket_total_' type-id='type-id-1' visibility='default' filepath='src/stack_trace_table.h' line='86' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- tcmalloc::StackTraceTable::Bucket** tcmalloc::StackTraceTable::table_ -->
          <var-decl name='table_' type-id='type-id-1245' visibility='default' filepath='src/stack_trace_table.h' line='87' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::StackTraceTable::StackTraceTable() -->
          <function-decl name='StackTraceTable' mangled-name='_ZN8tcmalloc15StackTraceTableC2Ev' filepath='src/stack_trace_table.h' line='50' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15StackTraceTableC2Ev'>
            <!-- implicit parameter of type 'tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1243' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- tcmalloc::StackTraceTable::~StackTraceTable(int) -->
          <function-decl name='~StackTraceTable' mangled-name='_ZN8tcmalloc15StackTraceTableD2Ev' filepath='src/stack_trace_table.h' line='51' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15StackTraceTableD2Ev'>
            <!-- implicit parameter of type 'tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1243' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::StackTraceTable::AddTrace(const tcmalloc::StackTrace&) -->
          <function-decl name='AddTrace' mangled-name='_ZN8tcmalloc15StackTraceTable8AddTraceERKNS_10StackTraceE' filepath='src/stack_trace_table.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15StackTraceTable8AddTraceERKNS_10StackTraceE'>
            <!-- implicit parameter of type 'tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1243' is-artificial='yes'/>
            <!-- parameter of type 'const tcmalloc::StackTrace&' -->
            <parameter type-id='type-id-1236'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void** tcmalloc::StackTraceTable::ReadStackTracesAndClear() -->
          <function-decl name='ReadStackTracesAndClear' mangled-name='_ZN8tcmalloc15StackTraceTable23ReadStackTracesAndClearEv' filepath='src/stack_trace_table.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15StackTraceTable23ReadStackTracesAndClearEv'>
            <!-- implicit parameter of type 'tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1243' is-artificial='yes'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::StackTraceTable::depth_total() -->
          <function-decl name='depth_total' mangled-name='_ZNK8tcmalloc15StackTraceTable11depth_totalEv' filepath='src/stack_trace_table.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1239' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::StackTraceTable::bucket_total() -->
          <function-decl name='bucket_total' mangled-name='_ZNK8tcmalloc15StackTraceTable12bucket_totalEv' filepath='src/stack_trace_table.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::StackTraceTable*' -->
            <parameter type-id='type-id-1239' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='tcmalloc'>
      <!-- class tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket> -->
      <class-decl name='PageHeapAllocator&lt;tcmalloc::StackTraceTable::Bucket&gt;' size-in-bits='256' visibility='default' filepath='src/page_heap_allocator.h' line='47' column='1' id='type-id-1231'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::kAllocIncrement -->
          <var-decl name='kAllocIncrement' type-id='type-id-134' visibility='default' filepath='src/page_heap_allocator.h' line='99' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_area_ -->
          <var-decl name='free_area_' type-id='type-id-113' visibility='default' filepath='src/page_heap_allocator.h' line='102' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_avail_ -->
          <var-decl name='free_avail_' type-id='type-id-57' visibility='default' filepath='src/page_heap_allocator.h' line='103' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_list_ -->
          <var-decl name='free_list_' type-id='type-id-53' visibility='default' filepath='src/page_heap_allocator.h' line='106' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::inuse_ -->
          <var-decl name='inuse_' type-id='type-id-1' visibility='default' filepath='src/page_heap_allocator.h' line='109' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE4InitEv' filepath='src/page_heap_allocator.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::StackTraceTable::Bucket* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::New() -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE3NewEv' filepath='src/page_heap_allocator.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- tcmalloc::StackTraceTable::Bucket* -->
            <return type-id='type-id-1244'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::Delete(tcmalloc::StackTraceTable::Bucket*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE6DeleteEPS2_' filepath='src/page_heap_allocator.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::StackTraceTable::Bucket*' -->
            <parameter type-id='type-id-1244'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::inuse() -->
          <function-decl name='inuse' mangled-name='_ZNK8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE5inuseEv' filepath='src/page_heap_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1233' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <namespace-decl name='tcmalloc'>
      <!-- struct tcmalloc::StackTrace -->
      <class-decl name='StackTrace' size-in-bits='2112' is-struct='yes' visibility='default' filepath='src/common.h' line='266' column='1' id='type-id-1234'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- uintptr_t tcmalloc::StackTrace::size -->
          <var-decl name='size' type-id='type-id-145' visibility='default' filepath='src/common.h' line='267' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- uintptr_t tcmalloc::StackTrace::depth -->
          <var-decl name='depth' type-id='type-id-145' visibility='default' filepath='src/common.h' line='268' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::StackTrace::stack[31] -->
          <var-decl name='stack' type-id='type-id-1247' visibility='default' filepath='src/common.h' line='269' column='1'/>
        </data-member>
      </class-decl>
    </namespace-decl>
    <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>* -->
    <pointer-type-def type-id='type-id-1231' size-in-bits='64' id='type-id-1246'/>
    <!-- void*[31] -->
    <array-type-def dimensions='1' type-id='type-id-53' size-in-bits='1984' id='type-id-1247'>
      <!-- <anonymous range>[31] -->
      <subrange length='31' type-id='type-id-5' id='type-id-1248'/>
    </array-type-def>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/stacktrace.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- int GetStackFrames(void**, int*, int, int) -->
    <function-decl name='GetStackFrames' mangled-name='_Z14GetStackFramesPPvPiii' filepath='src/stacktrace.cc' line='220' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z14GetStackFramesPPvPiii'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result' filepath='src/stacktrace.cc' line='220' column='1'/>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='sizes' filepath='src/stacktrace.cc' line='220' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='max_depth' filepath='src/stacktrace.cc' line='220' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='skip_count' filepath='src/stacktrace.cc' line='221' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int GetStackFramesWithContext(void**, int*, int, int, void*) -->
    <function-decl name='GetStackFramesWithContext' mangled-name='_Z25GetStackFramesWithContextPPvPiiiPKv' filepath='src/stacktrace.cc' line='225' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z25GetStackFramesWithContextPPvPiiiPKv'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result' filepath='src/stacktrace.cc' line='225' column='1'/>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='sizes' filepath='src/stacktrace.cc' line='225' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='max_depth' filepath='src/stacktrace.cc' line='225' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='skip_count' filepath='src/stacktrace.cc' line='226' column='1'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='uc' filepath='src/stacktrace.cc' line='226' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int GetStackTrace(void**, int, int) -->
    <function-decl name='GetStackTrace' mangled-name='_Z13GetStackTracePPvii' filepath='src/stacktrace.cc' line='232' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z13GetStackTracePPvii'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result' filepath='src/malloc_hook.cc' line='611' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='max_depth' filepath='src/malloc_hook.cc' line='611' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='skip_count' filepath='src/malloc_hook.cc' line='612' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int GetStackTraceWithContext(void**, int, int, void*) -->
    <function-decl name='GetStackTraceWithContext' mangled-name='_Z24GetStackTraceWithContextPPviiPKv' filepath='src/stacktrace.cc' line='237' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z24GetStackTraceWithContextPPviiPKv'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result' filepath='src/stacktrace.cc' line='237' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='max_depth' filepath='src/stacktrace.cc' line='237' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='skip_count' filepath='src/stacktrace.cc' line='238' column='1'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='uc' filepath='src/stacktrace.cc' line='238' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/static_vars.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/symbolize.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- class SymbolTable -->
    <class-decl name='SymbolTable' size-in-bits='448' visibility='default' filepath='src/symbolize.h' line='50' column='1' id='type-id-1249'>
      <member-type access='private'>
        <!-- typedef std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > SymbolTable::SymbolMap -->
        <typedef-decl name='SymbolMap' type-id='type-id-1251' filepath='src/symbolize.h' line='72' column='1' id='type-id-1250'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const int SymbolTable::kSymbolSize -->
        <var-decl name='kSymbolSize' type-id='type-id-134' visibility='default' filepath='src/symbolize.h' line='75' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- SymbolTable::SymbolMap SymbolTable::symbolization_table_ -->
        <var-decl name='symbolization_table_' type-id='type-id-1250' visibility='default' filepath='src/symbolize.h' line='78' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='384'>
        <!-- char* SymbolTable::symbol_buffer_ -->
        <var-decl name='symbol_buffer_' type-id='type-id-113' visibility='default' filepath='src/symbolize.h' line='81' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- SymbolTable::SymbolTable() -->
        <function-decl name='SymbolTable' filepath='src/symbolize.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SymbolTable*' -->
          <parameter type-id='type-id-1252' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- SymbolTable::~SymbolTable(int) -->
        <function-decl name='~SymbolTable' filepath='src/symbolize.h' line='54' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SymbolTable*' -->
          <parameter type-id='type-id-1252' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SymbolTable::Add(void*) -->
        <function-decl name='Add' mangled-name='_ZN11SymbolTable3AddEPKv' filepath='src/symbolize.h' line='60' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11SymbolTable3AddEPKv'>
          <!-- implicit parameter of type 'SymbolTable*' -->
          <parameter type-id='type-id-1252' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- const char* SymbolTable::GetSymbol(void*) -->
        <function-decl name='GetSymbol' mangled-name='_ZN11SymbolTable9GetSymbolEPKv' filepath='src/symbolize.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11SymbolTable9GetSymbolEPKv'>
          <!-- implicit parameter of type 'SymbolTable*' -->
          <parameter type-id='type-id-1252' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- const char* -->
          <return type-id='type-id-52'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- int SymbolTable::Symbolize() -->
        <function-decl name='Symbolize' mangled-name='_ZN11SymbolTable9SymbolizeEv' filepath='src/symbolize.h' line='69' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN11SymbolTable9SymbolizeEv'>
          <!-- implicit parameter of type 'SymbolTable*' -->
          <parameter type-id='type-id-1252' is-artificial='yes'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- SymbolTable* -->
    <pointer-type-def type-id='type-id-1249' size-in-bits='64' id='type-id-1252'/>
    <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1253' size-in-bits='64' id='type-id-1254'/>
    <!-- __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1255' size-in-bits='64' id='type-id-1256'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
    <qualified-type-def type-id='type-id-1253' const='yes' id='type-id-1257'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1257' size-in-bits='64' id='type-id-1258'/>
    <!-- const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1257' size-in-bits='64' id='type-id-1259'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1255' const='yes' id='type-id-1260'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1260' size-in-bits='64' id='type-id-1261'/>
    <!-- const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1260' size-in-bits='64' id='type-id-1262'/>
    <!-- const char*& -->
    <reference-type-def kind='lvalue' type-id='type-id-52' size-in-bits='64' id='type-id-1263'/>
    <!-- const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > -->
    <qualified-type-def type-id='type-id-1264' const='yes' id='type-id-1265'/>
    <!-- const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1265' size-in-bits='64' id='type-id-1266'/>
    <!-- const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1265' size-in-bits='64' id='type-id-1267'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1268' const='yes' id='type-id-1269'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1269' size-in-bits='64' id='type-id-1270'/>
    <!-- const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1269' size-in-bits='64' id='type-id-1271'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1272' const='yes' id='type-id-1273'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1273' size-in-bits='64' id='type-id-1274'/>
    <!-- const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1273' size-in-bits='64' id='type-id-1275'/>
    <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1276' const='yes' id='type-id-1277'/>
    <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1277' size-in-bits='64' id='type-id-1278'/>
    <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1277' size-in-bits='64' id='type-id-1279'/>
    <!-- const std::_Select1st<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1280' const='yes' id='type-id-1281'/>
    <!-- const std::_Select1st<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1281' size-in-bits='64' id='type-id-1282'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
    <qualified-type-def type-id='type-id-1283' const='yes' id='type-id-1284'/>
    <!-- const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1284' size-in-bits='64' id='type-id-1285'/>
    <!-- const std::allocator<std::pair<const void* const, const char*> > -->
    <qualified-type-def type-id='type-id-1286' const='yes' id='type-id-1287'/>
    <!-- const std::allocator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1287' size-in-bits='64' id='type-id-1288'/>
    <!-- const std::less<const void*> -->
    <qualified-type-def type-id='type-id-1289' const='yes' id='type-id-1290'/>
    <!-- const std::less<const void*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1290' size-in-bits='64' id='type-id-1291'/>
    <!-- const std::less<const void*>* -->
    <pointer-type-def type-id='type-id-1290' size-in-bits='64' id='type-id-1292'/>
    <!-- const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > -->
    <qualified-type-def type-id='type-id-1251' const='yes' id='type-id-1293'/>
    <!-- const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1293' size-in-bits='64' id='type-id-1294'/>
    <!-- const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1293' size-in-bits='64' id='type-id-1295'/>
    <!-- const std::pair<const void* const, const char*> -->
    <qualified-type-def type-id='type-id-1296' const='yes' id='type-id-1297'/>
    <!-- const std::pair<const void* const, const char*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1297' size-in-bits='64' id='type-id-1298'/>
    <!-- const std::pair<const void* const, const char*>* -->
    <pointer-type-def type-id='type-id-1297' size-in-bits='64' id='type-id-1299'/>
    <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1264' size-in-bits='64' id='type-id-1300'/>
    <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1264' size-in-bits='64' id='type-id-1301'/>
    <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>* -->
    <pointer-type-def type-id='type-id-1302' size-in-bits='64' id='type-id-1303'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1268' size-in-bits='64' id='type-id-1304'/>
    <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1268' size-in-bits='64' id='type-id-1305'/>
    <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1272' size-in-bits='64' id='type-id-1306'/>
    <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1272' size-in-bits='64' id='type-id-1307'/>
    <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1276' size-in-bits='64' id='type-id-1308'/>
    <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1276' size-in-bits='64' id='type-id-1309'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1283' size-in-bits='64' id='type-id-1310'/>
    <!-- std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1283' size-in-bits='64' id='type-id-1311'/>
    <!-- std::allocator<std::pair<const void* const, const char*> >* -->
    <pointer-type-def type-id='type-id-1286' size-in-bits='64' id='type-id-1312'/>
    <!-- std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-1251' size-in-bits='64' id='type-id-1313'/>
    <!-- std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >* -->
    <pointer-type-def type-id='type-id-1251' size-in-bits='64' id='type-id-1314'/>
    <!-- std::pair<const void* const, const char*>& -->
    <reference-type-def kind='lvalue' type-id='type-id-1296' size-in-bits='64' id='type-id-1315'/>
    <!-- std::pair<const void* const, const char*>* -->
    <pointer-type-def type-id='type-id-1296' size-in-bits='64' id='type-id-1316'/>
    <!-- std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>* -->
    <pointer-type-def type-id='type-id-1317' size-in-bits='64' id='type-id-1318'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- struct std::less<const void*> -->
      <class-decl name='less&lt;const void*&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='227' column='1' id='type-id-1289'>
        <!-- struct std::binary_function<const void*, const void*, bool> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1319'/>
        <member-function access='public'>
          <!-- bool std::less<const void*>::operator()(void* const&, void* const&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt4lessIPKvEclERKS1_S4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::less<const void*>*' -->
            <parameter type-id='type-id-1292' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::binary_function<const void*, const void*, bool> -->
      <class-decl name='binary_function&lt;const void*, const void*, bool&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='113' column='1' id='type-id-1319'/>
      <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
      <class-decl name='_Rb_tree_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='154' column='1' id='type-id-1272'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Base_ptr std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-736' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='219' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::_Rb_tree_iterator() -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::_Rb_tree_iterator(std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_Rb_tree_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const void* const, const char*>& std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1275' is-artificial='yes'/>
            <!-- std::pair<const void* const, const char*>& -->
            <return type-id='type-id-1315'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::pair<const void* const, const char*>* std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1275' is-artificial='yes'/>
            <!-- std::pair<const void* const, const char*>* -->
            <return type-id='type-id-1316'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& -->
            <return type-id='type-id-1306'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> >& -->
            <return type-id='type-id-1306'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1307' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator==(const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEeqERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1275' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1274'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_iterator<std::pair<const void* const, const char*> >::operator!=(const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt17_Rb_tree_iteratorISt4pairIKPKvPKcEEneERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='216' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1275' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1274'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Select1st<std::pair<const void* const, const char*> > -->
      <class-decl name='_Select1st&lt;std::pair&lt;const void* const, const char*&gt; &gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='482' column='1' id='type-id-1280'>
        <!-- struct std::unary_function<std::pair<const void* const, const char*>, const void* const> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1320'/>
        <member-function access='public'>
          <!-- void* const& std::_Select1st<std::pair<const void* const, const char*> >::operator()(std::pair<const void* const, const char*>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKPKvPKcEEclERS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1282' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1315'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void* const& std::_Select1st<std::pair<const void* const, const char*> >::operator()(const std::pair<const void* const, const char*>&) -->
          <function-decl name='operator()' mangled-name='_ZNKSt10_Select1stISt4pairIKPKvPKcEEclERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Select1st<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1282' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::unary_function<std::pair<const void* const, const char*>, const void* const> -->
      <class-decl name='unary_function&lt;std::pair&lt;const void* const, const char*&gt;, const void* const&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_function.h' line='101' column='1' id='type-id-1320'/>
      <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
      <class-decl name='_Rb_tree_const_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='224' column='1' id='type-id-1268'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_node_base::_Const_Base_ptr std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::_M_node -->
          <var-decl name='_M_node' type-id='type-id-737' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='294' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::_Rb_tree_const_iterator() -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::_Rb_tree_const_iterator(const std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::_Rb_tree_const_iterator(const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='_Rb_tree_const_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1274'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const void* const, const char*>& std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1271' is-artificial='yes'/>
            <!-- const std::pair<const void* const, const char*>& -->
            <return type-id='type-id-1298'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::pair<const void* const, const char*>* std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1271' is-artificial='yes'/>
            <!-- const std::pair<const void* const, const char*>* -->
            <return type-id='type-id-1299'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& -->
            <return type-id='type-id-1304'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='264' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >& -->
            <return type-id='type-id-1304'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZNSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1305' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator==(const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='operator==' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEeqERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1271' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1270'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >::operator!=(const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='operator!=' mangled-name='_ZNKSt23_Rb_tree_const_iteratorISt4pairIKPKvPKcEEneERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1271' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1270'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool> -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt;, bool&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-1317'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>::first -->
          <var-decl name='first' type-id='type-id-1272' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- bool std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>::second -->
          <var-decl name='second' type-id='type-id-55' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>*' -->
            <parameter type-id='type-id-1318' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>::pair(const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&, const bool&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool>*' -->
            <parameter type-id='type-id-1318' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_iterator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1274'/>
            <!-- parameter of type 'const bool&' -->
            <parameter type-id='type-id-478'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
      <class-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-1283'>
        <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1253'/>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1311' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::allocator(const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1311' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1285'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1311' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::pair<const void* const, const char*> -->
      <class-decl name='pair&lt;const void* const, const char*&gt;' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='68' column='1' id='type-id-1296'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- void* const std::pair<const void* const, const char*>::first -->
          <var-decl name='first' type-id='type-id-54' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='72' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- const char* std::pair<const void* const, const char*>::second -->
          <var-decl name='second' type-id='type-id-52' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='73' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- void std::pair<const void* const, const char*>::pair() -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const void* const, const char*>*' -->
            <parameter type-id='type-id-1316' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::pair<const void* const, const char*>::pair(void* const&, const char* const&) -->
          <function-decl name='pair' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_pair.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::pair<const void* const, const char*>*' -->
            <parameter type-id='type-id-1316' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- parameter of type 'const char* const&' -->
            <parameter type-id='type-id-479'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > -->
      <class-decl name='_Rb_tree&lt;const void*, std::pair&lt;const void* const, const char*&gt;, std::_Select1st&lt;std::pair&lt;const void* const, const char*&gt; &gt;, std::less&lt;const void*&gt;, std::allocator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='323' column='1' id='type-id-1264'>
        <member-type access='protected'>
          <!-- struct std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false> -->
          <class-decl name='_Rb_tree_impl&lt;std::less&lt;const void*&gt;, false&gt;' size-in-bits='384' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='427' column='1' id='type-id-1302'>
            <!-- class std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1283'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- std::less<const void*> std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_M_key_compare -->
              <var-decl name='_M_key_compare' type-id='type-id-1289' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='428' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- std::_Rb_tree_node_base std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_M_header -->
              <var-decl name='_M_header' type-id='type-id-549' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='429' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='320'>
              <!-- size_t std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_M_node_count -->
              <var-decl name='_M_node_count' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='430' column='1'/>
            </data-member>
            <member-function access='public'>
              <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_Rb_tree_impl() -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='432' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>*' -->
                <parameter type-id='type-id-1303' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_Rb_tree_impl(const std::less<const void*>&, const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&) -->
              <function-decl name='_Rb_tree_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='437' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>*' -->
                <parameter type-id='type-id-1303' is-artificial='yes'/>
                <!-- parameter of type 'const std::less<const void*>&' -->
                <parameter type-id='type-id-1291'/>
                <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&' -->
                <parameter type-id='type-id-1285'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>::_M_initialize() -->
              <function-decl name='_M_initialize' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE13_Rb_tree_implISA_Lb0EE13_M_initializeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false>*' -->
                <parameter type-id='type-id-1303' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree_impl<std::less<const void*>, false> std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-1302' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='453' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& -->
            <return type-id='type-id-1310'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_get_Node_allocator() -->
          <function-decl name='_M_get_Node_allocator' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE21_M_get_Node_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='349' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >& -->
            <return type-id='type-id-1285'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1286'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_get_node() -->
          <function-decl name='_M_get_node' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11_M_get_nodeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_put_node(std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_M_put_node' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11_M_put_nodeEPSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='362' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_create_node(const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_create_node' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE14_M_create_nodeERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_destroy_node(std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_M_destroy_node' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_clone_node(const std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_M_clone_node' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE13_M_clone_nodeEPKSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_root() -->
          <function-decl name='_M_root' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE7_M_rootEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_leftmost() -->
          <function-decl name='_M_leftmost' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11_M_leftmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node_base*& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node_base*& -->
            <return type-id='type-id-669'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_rightmost() -->
          <function-decl name='_M_rightmost' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE12_M_rightmostEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='477' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_begin() -->
          <function-decl name='_M_begin' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_M_beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1279'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_end() -->
          <function-decl name='_M_end' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6_M_endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='496' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1279'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const void* const, const char*>& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_S_valueEPKSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='500' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- const std::pair<const void* const, const char*>& -->
            <return type-id='type-id-1298'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- void* const& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6_S_keyEPKSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='504' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE7_S_leftEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='508' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_left() -->
          <function-decl name='_S_left' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE7_S_leftEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='512' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1279'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_S_rightEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_right() -->
          <function-decl name='_S_right' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_S_rightEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='520' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1279'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::pair<const void* const, const char*>& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_value() -->
          <function-decl name='_S_value' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_S_valueEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='524' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::pair<const void* const, const char*>& -->
            <return type-id='type-id-1298'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- void* const& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_key() -->
          <function-decl name='_S_key' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6_S_keyEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- void* const& -->
            <return type-id='type-id-172'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_S_minimumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_minimum() -->
          <function-decl name='_S_minimum' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_S_minimumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='536' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_S_maximumEPSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='540' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- std::_Rb_tree_node_base* -->
            <return type-id='type-id-668'/>
          </function-decl>
        </member-function>
        <member-function access='protected' static='yes'>
          <!-- const std::_Rb_tree_node_base* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_S_maximum() -->
          <function-decl name='_S_maximum' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_S_maximumEPKSt18_Rb_tree_node_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='544' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- const std::_Rb_tree_node_base* -->
            <return type-id='type-id-551'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_(const std::_Rb_tree_node_base*, const std::_Rb_tree_node_base*, const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE10_M_insert_EPKSt18_Rb_tree_node_baseSF_RKS6_'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-551'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_lower(std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_lower' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE15_M_insert_lowerEPSt18_Rb_tree_node_baseSE_RKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='893' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'std::_Rb_tree_node_base*' -->
            <parameter type-id='type-id-668'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_equal_lower(const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_equal_lower' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE21_M_insert_equal_lowerERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='911' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_copy(const std::_Rb_tree_node<std::pair<const void* const, const char*> >*, std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_M_copy' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE7_M_copyEPKSt13_Rb_tree_nodeIS6_EPSE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_erase(std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='_M_erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_M_eraseEPSt13_Rb_tree_nodeIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8_M_eraseEPSt13_Rb_tree_nodeIS6_E'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_lower_bound(std::_Rb_tree_node<std::pair<const void* const, const char*> >*, std::_Rb_tree_node<std::pair<const void* const, const char*> >*, void* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE14_M_lower_boundEPSt13_Rb_tree_nodeIS6_ESF_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='981' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_lower_bound(const std::_Rb_tree_node<std::pair<const void* const, const char*> >*, const std::_Rb_tree_node<std::pair<const void* const, const char*> >*, void* const&) -->
          <function-decl name='_M_lower_bound' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE14_M_lower_boundEPKSt13_Rb_tree_nodeIS6_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='997' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_upper_bound(std::_Rb_tree_node<std::pair<const void* const, const char*> >*, std::_Rb_tree_node<std::pair<const void* const, const char*> >*, void* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE14_M_upper_boundEPSt13_Rb_tree_nodeIS6_ESF_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1013' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_upper_bound(const std::_Rb_tree_node<std::pair<const void* const, const char*> >*, const std::_Rb_tree_node<std::pair<const void* const, const char*> >*, void* const&) -->
          <function-decl name='_M_upper_bound' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE14_M_upper_boundEPKSt13_Rb_tree_nodeIS6_ESG_RS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1029' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1279'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree() -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='591' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree(const std::less<const void*>&, const std::allocator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<const void*>&' -->
            <parameter type-id='type-id-1291'/>
            <!-- parameter of type 'const std::allocator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1288'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_Rb_tree(const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='597' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1266'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::~_Rb_tree(int) -->
          <function-decl name='~_Rb_tree' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::operator=(const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EEaSERKSC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1266'/>
            <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
            <return type-id='type-id-1300'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<const void*> std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- struct std::less<const void*> -->
            <return type-id='type-id-1289'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1321'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='654' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1322'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1321'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='662' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1322'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='670' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::swap(std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4swapERSC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1300'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool> std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_unique(const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_unique' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE16_M_insert_uniqueERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE16_M_insert_uniqueERKS6_'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool> -->
            <return type-id='type-id-1317'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_equal(const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_equal' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE15_M_insert_equalERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1189' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_unique_(std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_unique_' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS6_ERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE17_M_insert_unique_ESt23_Rb_tree_const_iteratorIS6_ERKS6_'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1268'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_insert_equal_(std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, const std::pair<const void* const, const char*>&) -->
          <function-decl name='_M_insert_equal_' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE16_M_insert_equal_ESt23_Rb_tree_const_iteratorIS6_ERKS6_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1268'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseESt17_Rb_tree_iteratorIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseESt23_Rb_tree_const_iteratorIS6_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1355' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1268'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(void* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseESt17_Rb_tree_iteratorIS6_ESE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1381' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseESt23_Rb_tree_const_iteratorIS6_ESE_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1394' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1268'/>
            <!-- parameter of type 'struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1268'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(void* const*, void* const*) -->
          <function-decl name='erase' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5eraseEPS3_SD_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1407' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='724' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::find(void* const&) -->
          <function-decl name='find' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1418' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::find(void* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE4findERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1431' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::count(void* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE5countERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::lower_bound(void* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::lower_bound(void* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11lower_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='748' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::upper_bound(void* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='752' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::upper_bound(void* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11upper_boundERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='756' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::equal_range(void* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1047' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1301' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1323'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::equal_range(void* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11equal_rangeERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1078' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1324'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::__rb_verify() -->
          <function-decl name='__rb_verify' mangled-name='_ZNKSt8_Rb_treeIPKvSt4pairIKS1_PKcESt10_Select1stIS6_ESt4lessIS1_ESaIS6_EE11__rb_verifyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_tree.h' line='1458' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1267' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > -->
      <class-decl name='map&lt;const void*, const char*, std::less&lt;const void*&gt;, std::allocator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' size-in-bits='384' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='87' column='1' id='type-id-1251'>
        <member-type access='private'>
          <!-- class std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::value_compare -->
          <class-decl name='value_compare' visibility='default' is-declaration-only='yes' id='type-id-1325'/>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::_Rb_tree<const void*, std::pair<const void* const, const char*>, std::_Select1st<std::pair<const void* const, const char*> >, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::_M_t -->
          <var-decl name='_M_t' type-id='type-id-1264' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='128' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::map() -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='150' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::map(const std::less<const void*>&, const std::allocator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='159' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'const std::less<const void*>&' -->
            <parameter type-id='type-id-1291'/>
            <!-- parameter of type 'const std::allocator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1288'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::map(const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='map' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1294'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::operator=(const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEEaSERKSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1294'/>
            <!-- std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >& -->
            <return type-id='type-id-1313'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::allocator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- class std::allocator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1286'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::end() -->
          <function-decl name='end' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1321'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1322'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1321'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1322'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='415' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='420' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char*& std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::operator[](void* const&) -->
          <function-decl name='operator[]' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEEixERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='442' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- const char*& -->
            <return type-id='type-id-1263'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char*& std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::at(void* const&) -->
          <function-decl name='at' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE2atERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='464' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- const char*& -->
            <return type-id='type-id-1263'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* const& std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::at(void* const&) -->
          <function-decl name='at' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE2atERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- const char* const& -->
            <return type-id='type-id-479'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool> std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::insert(const std::pair<const void* const, const char*>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE6insertERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='499' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, bool> -->
            <return type-id='type-id-1317'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::insert(std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, const std::pair<const void* const, const char*>&) -->
          <function-decl name='insert' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE6insertESt17_Rb_tree_iteratorIS8_ERKS8_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5eraseESt17_Rb_tree_iteratorIS8_E' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(void* const&) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5eraseERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='581' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::erase(std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> >) -->
          <function-decl name='erase' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5eraseESt17_Rb_tree_iteratorIS8_ESC_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='596' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- parameter of type 'struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> >' -->
            <parameter type-id='type-id-1272'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::swap(std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='swap' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4swapERSA_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1313'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::less<const void*> std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::key_comp() -->
          <function-decl name='key_comp' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE8key_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- struct std::less<const void*> -->
            <return type-id='type-id-1289'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::value_compare std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::value_comp() -->
          <function-decl name='value_comp' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE10value_compEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='642' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- class std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::value_compare -->
            <return type-id='type-id-1325'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::find(void* const&) -->
          <function-decl name='find' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4findERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='658' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::find(void* const&) -->
          <function-decl name='find' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE4findERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='673' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::count(void* const&) -->
          <function-decl name='count' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE5countERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='685' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::lower_bound(void* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11lower_boundERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='700' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::lower_bound(void* const&) -->
          <function-decl name='lower_bound' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11lower_boundERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='715' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::upper_bound(void* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11upper_boundERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1272'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::upper_bound(void* const&) -->
          <function-decl name='upper_bound' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11upper_boundERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='735' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > -->
            <return type-id='type-id-1268'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::equal_range(void* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11equal_rangeERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='754' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1314' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1323'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >::equal_range(void* const&) -->
          <function-decl name='equal_range' mangled-name='_ZNKSt3mapIPKvPKcSt4lessIS1_ESaISt4pairIKS1_S3_EEE11equal_rangeERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_map.h' line='773' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::map<const void*, const char*, std::less<const void*>, std::allocator<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1295' is-artificial='yes'/>
            <!-- parameter of type 'void* const&' -->
            <parameter type-id='type-id-172'/>
            <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
            <return type-id='type-id-1324'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<std::pair<const void* const, const char*> > -->
      <class-decl name='allocator&lt;std::pair&lt;const void* const, const char*&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-1286'>
        <!-- class __gnu_cxx::new_allocator<std::pair<const void* const, const char*> > -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1255'/>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<const void* const, const char*> >::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1312' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<const void* const, const char*> >::allocator(const std::allocator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1312' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1288'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<std::pair<const void* const, const char*> >::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1312' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<std::pair<const void* const, const char*> >::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >(const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1312' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1285'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Rb_tree_node<std::pair<const void* const, const char*> > -->
      <class-decl name='_Rb_tree_node&lt;std::pair&lt;const void* const, const char*&gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1276'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-1321'/>
      <!-- class std::reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
      <class-decl name='reverse_iterator&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-1322'/>
      <!-- struct std::pair<std::_Rb_tree_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_iterator<std::pair<const void* const, const char*> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt;, std::_Rb_tree_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1323'/>
      <!-- struct std::pair<std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> >, std::_Rb_tree_const_iterator<std::pair<const void* const, const char*> > > -->
      <class-decl name='pair&lt;std::_Rb_tree_const_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt;, std::_Rb_tree_const_iterator&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1324'/>
    </namespace-decl>
    <!-- namespace __gnu_cxx -->
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > > -->
      <class-decl name='new_allocator&lt;std::_Rb_tree_node&lt;std::pair&lt;const void* const, const char*&gt; &gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-1253'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::new_allocator(const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >&' -->
            <parameter type-id='type-id-1258'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::address(std::_Rb_tree_node<std::pair<const void* const, const char*> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE7addressERS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1259' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1308'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::address(const std::_Rb_tree_node<std::pair<const void* const, const char*> >&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE7addressERKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1259' is-artificial='yes'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1278'/>
            <!-- const std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1279'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE8allocateEmS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::_Rb_tree_node<std::pair<const void* const, const char*> >* -->
            <return type-id='type-id-1309'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::deallocate(std::_Rb_tree_node<std::pair<const void* const, const char*> >*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE10deallocateEPS9_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1259' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::construct(std::_Rb_tree_node<std::pair<const void* const, const char*> >*, const std::_Rb_tree_node<std::pair<const void* const, const char*> >&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE9constructEPS9_RKS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- parameter of type 'const std::_Rb_tree_node<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1278'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >::destroy(std::_Rb_tree_node<std::pair<const void* const, const char*> >*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt13_Rb_tree_nodeISt4pairIKPKvPKcEEE7destroyEPS9_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const void* const, const char*> > >*' -->
            <parameter type-id='type-id-1254' is-artificial='yes'/>
            <!-- parameter of type 'std::_Rb_tree_node<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1309'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<std::pair<const void* const, const char*> > -->
      <class-decl name='new_allocator&lt;std::pair&lt;const void* const, const char*&gt; &gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-1255'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::new_allocator(const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >&' -->
            <parameter type-id='type-id-1261'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<const void* const, const char*>* __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::address(std::pair<const void* const, const char*>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE7addressERS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1262' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1315'/>
            <!-- std::pair<const void* const, const char*>* -->
            <return type-id='type-id-1316'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const std::pair<const void* const, const char*>* __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::address(const std::pair<const void* const, const char*>&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE7addressERKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1262' is-artificial='yes'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- const std::pair<const void* const, const char*>* -->
            <return type-id='type-id-1299'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::pair<const void* const, const char*>* __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE8allocateEmS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- std::pair<const void* const, const char*>* -->
            <return type-id='type-id-1316'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::deallocate(std::pair<const void* const, const char*>*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE10deallocateEPS7_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const void* const, const char*>*' -->
            <parameter type-id='type-id-1316'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1262' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::construct(std::pair<const void* const, const char*>*, const std::pair<const void* const, const char*>&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE9constructEPS7_RKS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const void* const, const char*>*' -->
            <parameter type-id='type-id-1316'/>
            <!-- parameter of type 'const std::pair<const void* const, const char*>&' -->
            <parameter type-id='type-id-1298'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<std::pair<const void* const, const char*> >::destroy(std::pair<const void* const, const char*>*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorISt4pairIKPKvPKcEE7destroyEPS7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<std::pair<const void* const, const char*> >*' -->
            <parameter type-id='type-id-1256' is-artificial='yes'/>
            <!-- parameter of type 'std::pair<const void* const, const char*>*' -->
            <parameter type-id='type-id-1316'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- void tcmalloc::DumpProcSelfMaps(RawFD) -->
      <function-decl name='DumpProcSelfMaps' mangled-name='_ZN8tcmalloc16DumpProcSelfMapsEi' filepath='src/base/sysinfo.h' line='233' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc16DumpProcSelfMapsEi'>
        <!-- parameter of type 'typedef RawFD' -->
        <parameter type-id='type-id-70'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead'>
      <!-- std::string FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_symbolize_pprof -->
      <var-decl name='FLAGS_symbolize_pprof' type-id='type-id-800' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead21FLAGS_symbolize_pprofE' visibility='default' filepath='src/symbolize.cc' line='68' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead21FLAGS_symbolize_pprofE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_nosymbolize_pprof -->
      <var-decl name='FLAGS_nosymbolize_pprof' type-id='type-id-60' mangled-name='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_nosymbolize_pprofE' visibility='default' filepath='src/symbolize.cc' line='70' column='1' elf-symbol-id='_ZN62FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead23FLAGS_nosymbolize_pprofE'/>
    </namespace-decl>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/system-alloc.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- SysAllocator*[2] -->
    <array-type-def dimensions='1' type-id='type-id-874' size-in-bits='128' id='type-id-1326'>
      <!-- <anonymous range>[2] -->
      <subrange length='2' type-id='type-id-5' id='type-id-1327'/>
    </array-type-def>
    <!-- bool[2] -->
    <array-type-def dimensions='1' type-id='type-id-55' size-in-bits='16' id='type-id-1328'>
      <!-- <anonymous range>[2] -->
      <subrange length='2' type-id='type-id-5' id='type-id-1327'/>
    </array-type-def>
    <!-- const char*[2] -->
    <array-type-def dimensions='1' type-id='type-id-52' size-in-bits='128' id='type-id-1329'>
      <!-- <anonymous range>[2] -->
      <subrange length='2' type-id='type-id-5' id='type-id-1327'/>
    </array-type-def>
    <!-- class MmapSysAllocator -->
    <class-decl name='MmapSysAllocator' size-in-bits='64' visibility='default' filepath='src/system-alloc.cc' line='158' column='1' id='type-id-1330'>
      <!-- class SysAllocator -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-929'/>
      <member-function access='private' constructor='yes'>
        <!-- MmapSysAllocator::MmapSysAllocator() -->
        <function-decl name='MmapSysAllocator' filepath='src/system-alloc.cc' line='160' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'MmapSysAllocator*' -->
          <parameter type-id='type-id-1331' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* MmapSysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN16MmapSysAllocator5AllocEmPmm' filepath='src/system-alloc.cc' line='274' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16MmapSysAllocator5AllocEmPmm'>
          <!-- implicit parameter of type 'MmapSysAllocator*' -->
          <parameter type-id='type-id-1331' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class SbrkSysAllocator -->
    <class-decl name='SbrkSysAllocator' size-in-bits='64' visibility='default' filepath='src/system-alloc.cc' line='150' column='1' id='type-id-1332'>
      <!-- class SysAllocator -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-929'/>
      <member-function access='private' constructor='yes'>
        <!-- SbrkSysAllocator::SbrkSysAllocator() -->
        <function-decl name='SbrkSysAllocator' filepath='src/system-alloc.cc' line='152' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SbrkSysAllocator*' -->
          <parameter type-id='type-id-1333' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* SbrkSysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN16SbrkSysAllocator5AllocEmPmm' filepath='src/system-alloc.cc' line='203' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16SbrkSysAllocator5AllocEmPmm'>
          <!-- implicit parameter of type 'SbrkSysAllocator*' -->
          <parameter type-id='type-id-1333' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class DefaultSysAllocator -->
    <class-decl name='DefaultSysAllocator' size-in-bits='384' visibility='default' filepath='src/system-alloc.cc' line='173' column='1' id='type-id-1334'>
      <!-- class SysAllocator -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-929'/>
      <data-member access='private' static='yes'>
        <!-- static const int DefaultSysAllocator::kMaxAllocators -->
        <var-decl name='kMaxAllocators' type-id='type-id-134' visibility='default' filepath='src/system-alloc.cc' line='193' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- bool DefaultSysAllocator::failed_[2] -->
        <var-decl name='failed_' type-id='type-id-1328' visibility='default' filepath='src/system-alloc.cc' line='194' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='128'>
        <!-- SysAllocator* DefaultSysAllocator::allocs_[2] -->
        <var-decl name='allocs_' type-id='type-id-1326' visibility='default' filepath='src/system-alloc.cc' line='195' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='256'>
        <!-- const char* DefaultSysAllocator::names_[2] -->
        <var-decl name='names_' type-id='type-id-1329' visibility='default' filepath='src/system-alloc.cc' line='196' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- DefaultSysAllocator::DefaultSysAllocator() -->
        <function-decl name='DefaultSysAllocator' filepath='src/system-alloc.cc' line='175' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'DefaultSysAllocator*' -->
          <parameter type-id='type-id-1335' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void DefaultSysAllocator::SetChildAllocator(SysAllocator*, unsigned int, const char*) -->
        <function-decl name='SetChildAllocator' mangled-name='_ZN19DefaultSysAllocator17SetChildAllocatorEP12SysAllocatorjPKc' filepath='src/system-alloc.cc' line='182' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'DefaultSysAllocator*' -->
          <parameter type-id='type-id-1335' is-artificial='yes'/>
          <!-- parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874'/>
          <!-- parameter of type 'unsigned int' -->
          <parameter type-id='type-id-59'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* DefaultSysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN19DefaultSysAllocator5AllocEmPmm' filepath='src/system-alloc.cc' line='431' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN19DefaultSysAllocator5AllocEmPmm'>
          <!-- implicit parameter of type 'DefaultSysAllocator*' -->
          <parameter type-id='type-id-1335' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class DevMemSysAllocator -->
    <class-decl name='DevMemSysAllocator' size-in-bits='64' visibility='default' filepath='src/system-alloc.cc' line='166' column='1' id='type-id-1336'>
      <!-- class SysAllocator -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-929'/>
      <member-function access='private' constructor='yes'>
        <!-- DevMemSysAllocator::DevMemSysAllocator() -->
        <function-decl name='DevMemSysAllocator' filepath='src/system-alloc.cc' line='168' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'DevMemSysAllocator*' -->
          <parameter type-id='type-id-1337' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* DevMemSysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN18DevMemSysAllocator5AllocEmPmm' filepath='src/system-alloc.cc' line='342' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN18DevMemSysAllocator5AllocEmPmm'>
          <!-- implicit parameter of type 'DevMemSysAllocator*' -->
          <parameter type-id='type-id-1337' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- DefaultSysAllocator* -->
    <pointer-type-def type-id='type-id-1334' size-in-bits='64' id='type-id-1335'/>
    <!-- DevMemSysAllocator* -->
    <pointer-type-def type-id='type-id-1336' size-in-bits='64' id='type-id-1337'/>
    <!-- MmapSysAllocator* -->
    <pointer-type-def type-id='type-id-1330' size-in-bits='64' id='type-id-1331'/>
    <!-- SbrkSysAllocator* -->
    <pointer-type-def type-id='type-id-1332' size-in-bits='64' id='type-id-1333'/>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead'>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_malloc_devmem_start -->
      <var-decl name='FLAGS_malloc_devmem_start' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_startE' visibility='default' filepath='src/system-alloc.cc' line='130' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_startE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_nomalloc_devmem_start -->
      <var-decl name='FLAGS_nomalloc_devmem_start' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_startE' visibility='default' filepath='src/system-alloc.cc' line='133' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_startE'/>
      <!-- int32 FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_malloc_devmem_limit -->
      <var-decl name='FLAGS_malloc_devmem_limit' type-id='type-id-69' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_limitE' visibility='default' filepath='src/system-alloc.cc' line='134' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead25FLAGS_malloc_devmem_limitE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead::FLAGS_nomalloc_devmem_limit -->
      <var-decl name='FLAGS_nomalloc_devmem_limit' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_limitE' visibility='default' filepath='src/system-alloc.cc' line='137' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int32_instead27FLAGS_nomalloc_devmem_limitE'/>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead'>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_skip_sbrk -->
      <var-decl name='FLAGS_malloc_skip_sbrk' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_sbrkE' visibility='default' filepath='src/system-alloc.cc' line='138' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_sbrkE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_skip_sbrk -->
      <var-decl name='FLAGS_nomalloc_skip_sbrk' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_sbrkE' visibility='default' filepath='src/system-alloc.cc' line='140' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_sbrkE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_skip_mmap -->
      <var-decl name='FLAGS_malloc_skip_mmap' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_mmapE' visibility='default' filepath='src/system-alloc.cc' line='141' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead22FLAGS_malloc_skip_mmapE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_skip_mmap -->
      <var-decl name='FLAGS_nomalloc_skip_mmap' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_mmapE' visibility='default' filepath='src/system-alloc.cc' line='143' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead24FLAGS_nomalloc_skip_mmapE'/>
      <!-- bool FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_malloc_disable_memory_release -->
      <var-decl name='FLAGS_malloc_disable_memory_release' type-id='type-id-55' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_malloc_disable_memory_releaseE' visibility='default' filepath='src/system-alloc.cc' line='144' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead35FLAGS_malloc_disable_memory_releaseE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead::FLAGS_nomalloc_disable_memory_release -->
      <var-decl name='FLAGS_nomalloc_disable_memory_release' type-id='type-id-60' mangled-name='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomalloc_disable_memory_releaseE' visibility='default' filepath='src/system-alloc.cc' line='147' column='1' elf-symbol-id='_ZN60FLAG__namespace_do_not_use_directly_use_DECLARE_bool_instead37FLAGS_nomalloc_disable_memory_releaseE'/>
    </namespace-decl>
    <!-- SysAllocator* tc_get_sysalloc_override(SysAllocator*) -->
    <function-decl name='tc_get_sysalloc_override' mangled-name='_Z24tc_get_sysalloc_overrideP12SysAllocator' filepath='src/system-alloc.cc' line='451' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z24tc_get_sysalloc_overrideP12SysAllocator'>
      <!-- parameter of type 'SysAllocator*' -->
      <parameter type-id='type-id-874' name='def' filepath='src/system-alloc.cc' line='451' column='1'/>
      <!-- SysAllocator* -->
      <return type-id='type-id-874'/>
    </function-decl>
    <!-- void InitSystemAllocators() -->
    <function-decl name='InitSystemAllocators' mangled-name='_Z20InitSystemAllocatorsv' filepath='src/system-alloc.cc' line='457' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z20InitSystemAllocatorsv'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void TCMalloc_SystemCommit(void*, size_t) -->
    <function-decl name='TCMalloc_SystemCommit' mangled-name='_Z21TCMalloc_SystemCommitPvm' filepath='src/system-alloc.cc' line='548' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z21TCMalloc_SystemCommitPvm'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- bool TCMalloc_SystemRelease(void*, size_t) -->
    <function-decl name='TCMalloc_SystemRelease' mangled-name='_Z22TCMalloc_SystemReleasePvm' filepath='src/system-alloc.cc' line='510' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z22TCMalloc_SystemReleasePvm'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='start' filepath='src/system-alloc.cc' line='510' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='length' filepath='src/system-alloc.cc' line='510' column='1'/>
      <!-- bool -->
      <return type-id='type-id-55'/>
    </function-decl>
    <!-- void* TCMalloc_SystemAlloc(size_t, size_t*, size_t) -->
    <function-decl name='TCMalloc_SystemAlloc' mangled-name='_Z20TCMalloc_SystemAllocmPmm' filepath='src/system-alloc.cc' line='480' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_Z20TCMalloc_SystemAllocmPmm'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='size' filepath='src/system-alloc.cc' line='480' column='1'/>
      <!-- parameter of type 'size_t*' -->
      <parameter type-id='type-id-252' name='actual_size' filepath='src/system-alloc.cc' line='480' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='alignment' filepath='src/system-alloc.cc' line='481' column='1'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- SysAllocator* sys_alloc -->
    <var-decl name='sys_alloc' type-id='type-id-874' mangled-name='sys_alloc' visibility='default' filepath='src/system-alloc.cc' line='124' column='1' elf-symbol-id='sys_alloc'/>
    <!-- size_t TCMalloc_SystemTaken -->
    <var-decl name='TCMalloc_SystemTaken' type-id='type-id-57' mangled-name='TCMalloc_SystemTaken' visibility='default' filepath='src/system-alloc.cc' line='127' column='1' elf-symbol-id='TCMalloc_SystemTaken'/>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/tcmalloc.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- AtomicWord[8] -->
    <array-type-def dimensions='1' type-id='type-id-798' size-in-bits='512' id='type-id-799'>
      <!-- <anonymous range>[8] -->
      <subrange length='8' type-id='type-id-5' id='type-id-801'/>
    </array-type-def>
    <!-- bool -->
    <type-decl name='bool' size-in-bits='8' id='type-id-55'/>
    <!-- char -->
    <type-decl name='char' size-in-bits='8' id='type-id-60'/>
    <!-- char[1] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='8' id='type-id-1338'>
      <!-- <anonymous range>[1] -->
      <subrange length='1' type-id='type-id-5' id='type-id-1339'/>
    </array-type-def>
    <!-- char[20] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='160' id='type-id-1340'>
      <!-- <anonymous range>[20] -->
      <subrange length='20' type-id='type-id-5' id='type-id-802'/>
    </array-type-def>
    <!-- char[48] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='384' id='type-id-191'>
      <!-- <anonymous range>[48] -->
      <subrange length='48' type-id='type-id-5' id='type-id-804'/>
    </array-type-def>
    <!-- char[4] -->
    <array-type-def dimensions='1' type-id='type-id-60' size-in-bits='32' id='type-id-1341'>
      <!-- <anonymous range>[4] -->
      <subrange length='4' type-id='type-id-5' id='type-id-151'/>
    </array-type-def>
    <!-- struct typedef __va_list_tag __va_list_tag -->
    <class-decl name='typedef __va_list_tag __va_list_tag' size-in-bits='192' is-struct='yes' visibility='default' id='type-id-68'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- unsigned int typedef __va_list_tag __va_list_tag::gp_offset -->
        <var-decl name='gp_offset' type-id='type-id-59' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- unsigned int typedef __va_list_tag __va_list_tag::fp_offset -->
        <var-decl name='fp_offset' type-id='type-id-59' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- void* typedef __va_list_tag __va_list_tag::overflow_arg_area -->
        <var-decl name='overflow_arg_area' type-id='type-id-53' visibility='default'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- void* typedef __va_list_tag __va_list_tag::reg_save_area -->
        <var-decl name='reg_save_area' type-id='type-id-53' visibility='default'/>
      </data-member>
    </class-decl>
    <!-- double -->
    <type-decl name='double' size-in-bits='64' id='type-id-2'/>
    <!-- double[1024] -->
    <array-type-def dimensions='1' type-id='type-id-2' size-in-bits='65536' id='type-id-1342'>
      <!-- <anonymous range>[1024] -->
      <subrange length='1024' type-id='type-id-5' id='type-id-1195'/>
    </array-type-def>
    <!-- float -->
    <type-decl name='float' size-in-bits='32' id='type-id-1343'/>
    <!-- int -->
    <type-decl name='int' size-in-bits='32' id='type-id-1'/>
    <!-- int64[128] -->
    <array-type-def dimensions='1' type-id='type-id-93' size-in-bits='8192' id='type-id-1344'>
      <!-- <anonymous range>[128] -->
      <subrange length='128' type-id='type-id-5' id='type-id-1345'/>
    </array-type-def>
    <!-- int[88] -->
    <array-type-def dimensions='1' type-id='type-id-1' size-in-bits='2816' id='type-id-1346'>
      <!-- <anonymous range>[88] -->
      <subrange length='88' type-id='type-id-5' id='type-id-1347'/>
    </array-type-def>
    <!-- long double -->
    <type-decl name='long double' size-in-bits='128' id='type-id-1348'/>
    <!-- long int -->
    <type-decl name='long int' size-in-bits='64' id='type-id-80'/>
    <!-- long long int -->
    <type-decl name='long long int' size-in-bits='64' id='type-id-1029'/>
    <!-- long long unsigned int -->
    <type-decl name='long long unsigned int' size-in-bits='64' id='type-id-1030'/>
    <!-- signed char -->
    <type-decl name='signed char' size-in-bits='8' id='type-id-1349'/>
    <!-- size_t[88] -->
    <array-type-def dimensions='1' type-id='type-id-57' size-in-bits='5632' id='type-id-1350'>
      <!-- <anonymous range>[88] -->
      <subrange length='88' type-id='type-id-5' id='type-id-1347'/>
    </array-type-def>
    <!-- TCEntry[64] -->
    <array-type-def dimensions='1' type-id='type-id-1351' size-in-bits='8192' id='type-id-1352'>
      <!-- <anonymous range>[64] -->
      <subrange length='64' type-id='type-id-5' id='type-id-1191'/>
    </array-type-def>
    <!-- CentralFreeListPadded[88] -->
    <array-type-def dimensions='1' type-id='type-id-1353' size-in-bits='856064' id='type-id-1354'>
      <!-- <anonymous range>[88] -->
      <subrange length='88' type-id='type-id-5' id='type-id-1347'/>
    </array-type-def>
    <!-- SpanList[128] -->
    <array-type-def dimensions='1' type-id='type-id-1355' size-in-bits='98304' id='type-id-1356'>
      <!-- <anonymous range>[128] -->
      <subrange length='128' type-id='type-id-5' id='type-id-1345'/>
    </array-type-def>
    <!-- FreeList[88] -->
    <array-type-def dimensions='1' type-id='type-id-1357' size-in-bits='16896' id='type-id-1358'>
      <!-- <anonymous range>[88] -->
      <subrange length='88' type-id='type-id-5' id='type-id-1347'/>
    </array-type-def>
    <!-- unnamed&#45;enum&#45;underlying&#45;type&#45;32 -->
    <type-decl name='unnamed-enum-underlying-type-32' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='type-id-84'/>
    <!-- unsigned char -->
    <type-decl name='unsigned char' size-in-bits='8' id='type-id-3'/>
    <!-- unsigned char[2169] -->
    <array-type-def dimensions='1' type-id='type-id-3' size-in-bits='17352' id='type-id-1359'>
      <!-- <anonymous range>[2169] -->
      <subrange length='2169' type-id='type-id-5' id='type-id-1360'/>
    </array-type-def>
    <!-- unsigned int -->
    <type-decl name='unsigned int' size-in-bits='32' id='type-id-59'/>
    <!-- unsigned long int -->
    <type-decl name='unsigned long int' size-in-bits='64' id='type-id-5'/>
    <!-- unsigned long int[65536] -->
    <array-type-def dimensions='1' type-id='type-id-5' size-in-bits='4194304' id='type-id-1361'>
      <!-- <anonymous range>[65536] -->
      <subrange length='65536' type-id='type-id-5' id='type-id-1362'/>
    </array-type-def>
    <!-- unsigned short int -->
    <type-decl name='unsigned short int' size-in-bits='16' id='type-id-14'/>
    <!-- variadic parameter type -->
    <type-decl name='variadic parameter type' id='type-id-1363'/>
    <!-- void -->
    <type-decl name='void' id='type-id-56'/>
    <!-- void*[31] -->
    <array-type-def dimensions='1' type-id='type-id-53' size-in-bits='1984' id='type-id-1247'>
      <!-- <anonymous range>[31] -->
      <subrange length='31' type-id='type-id-5' id='type-id-1248'/>
    </array-type-def>
    <!-- volatile unsigned long int[65536] -->
    <array-type-def dimensions='1' type-id='type-id-1364' size-in-bits='4194304' id='type-id-1365'>
      <!-- <anonymous range>[65536] -->
      <subrange length='65536' type-id='type-id-5' id='type-id-1362'/>
    </array-type-def>
    <!-- wchar_t -->
    <type-decl name='wchar_t' size-in-bits='32' id='type-id-1366'/>
    <!-- typedef unsigned long int size_t -->
    <typedef-decl name='size_t' type-id='type-id-5' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/include/stddef.h' line='211' column='1' id='type-id-57'/>
    <!-- struct lldiv_t -->
    <class-decl name='lldiv_t' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/include/stdlib.h' line='119' column='1' id='type-id-1367'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- long long int lldiv_t::quot -->
        <var-decl name='quot' type-id='type-id-1029' visibility='default' filepath='/usr/include/stdlib.h' line='120' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- long long int lldiv_t::rem -->
        <var-decl name='rem' type-id='type-id-1029' visibility='default' filepath='/usr/include/stdlib.h' line='121' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef long int ptrdiff_t -->
    <typedef-decl name='ptrdiff_t' type-id='type-id-80' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/include/stddef.h' line='149' column='1' id='type-id-208'/>
    <!-- class TCMalloc_PageMap3<35> -->
    <class-decl name='TCMalloc_PageMap3&lt;35&gt;' size-in-bits='128' visibility='default' filepath='src/pagemap.h' line='209' column='1' id='type-id-1368'>
      <member-type access='private'>
        <!-- struct TCMalloc_PageMap3<35>::Node -->
        <class-decl name='Node' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1369'/>
      </member-type>
      <member-type access='private'>
        <!-- struct TCMalloc_PageMap3<35>::Leaf -->
        <class-decl name='Leaf' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-1370'/>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const int TCMalloc_PageMap3<35>::INTERIOR_BITS -->
        <var-decl name='INTERIOR_BITS' type-id='type-id-134' visibility='default' filepath='src/pagemap.h' line='212' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int TCMalloc_PageMap3<35>::INTERIOR_LENGTH -->
        <var-decl name='INTERIOR_LENGTH' type-id='type-id-134' visibility='default' filepath='src/pagemap.h' line='213' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int TCMalloc_PageMap3<35>::LEAF_BITS -->
        <var-decl name='LEAF_BITS' type-id='type-id-134' visibility='default' filepath='src/pagemap.h' line='216' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int TCMalloc_PageMap3<35>::LEAF_LENGTH -->
        <var-decl name='LEAF_LENGTH' type-id='type-id-134' visibility='default' filepath='src/pagemap.h' line='217' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- TCMalloc_PageMap3<35>::Node* TCMalloc_PageMap3<35>::root_ -->
        <var-decl name='root_' type-id='type-id-1371' visibility='default' filepath='src/pagemap.h' line='229' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- void* (unsigned long int)* TCMalloc_PageMap3<35>::allocator_ -->
        <var-decl name='allocator_' type-id='type-id-286' visibility='default' filepath='src/pagemap.h' line='230' column='1'/>
      </data-member>
      <member-function access='private'>
        <!-- TCMalloc_PageMap3<35>::Node* TCMalloc_PageMap3<35>::NewNode() -->
        <function-decl name='NewNode' mangled-name='_ZN17TCMalloc_PageMap3ILi35EE7NewNodeEv' filepath='src/pagemap.h' line='232' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1372' is-artificial='yes'/>
          <!-- TCMalloc_PageMap3<35>::Node* -->
          <return type-id='type-id-1371'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void TCMalloc_PageMap3<35>::TCMalloc_PageMap3(void* (unsigned long int)*) -->
        <function-decl name='TCMalloc_PageMap3' filepath='src/pagemap.h' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1372' is-artificial='yes'/>
          <!-- parameter of type 'void* (unsigned long int)*' -->
          <parameter type-id='type-id-286'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void* TCMalloc_PageMap3<35>::get(unsigned long int) -->
        <function-decl name='get' mangled-name='_ZNK17TCMalloc_PageMap3ILi35EE3getEm' filepath='src/pagemap.h' line='248' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1373' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void TCMalloc_PageMap3<35>::set(unsigned long int, void*) -->
        <function-decl name='set' mangled-name='_ZN17TCMalloc_PageMap3ILi35EE3setEmPv' filepath='src/pagemap.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1372' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool TCMalloc_PageMap3<35>::Ensure(unsigned long int, unsigned long int) -->
        <function-decl name='Ensure' mangled-name='_ZN17TCMalloc_PageMap3ILi35EE6EnsureEmm' filepath='src/pagemap.h' line='267' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1372' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void TCMalloc_PageMap3<35>::PreallocateMoreMemory() -->
        <function-decl name='PreallocateMoreMemory' mangled-name='_ZN17TCMalloc_PageMap3ILi35EE21PreallocateMoreMemoryEv' filepath='src/pagemap.h' line='297' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1372' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void* TCMalloc_PageMap3<35>::Next(unsigned long int) -->
        <function-decl name='Next' mangled-name='_ZNK17TCMalloc_PageMap3ILi35EE4NextEm' filepath='src/pagemap.h' line='300' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const TCMalloc_PageMap3<35>*' -->
          <parameter type-id='type-id-1373' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef int (void*, void*)* __compar_fn_t -->
    <typedef-decl name='__compar_fn_t' type-id='type-id-1374' filepath='/usr/include/stdlib.h' line='742' column='1' id='type-id-1375'/>
    <!-- struct div_t -->
    <class-decl name='div_t' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/include/stdlib.h' line='99' column='1' id='type-id-1376'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int div_t::quot -->
        <var-decl name='quot' type-id='type-id-1' visibility='default' filepath='/usr/include/stdlib.h' line='100' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int div_t::rem -->
        <var-decl name='rem' type-id='type-id-1' visibility='default' filepath='/usr/include/stdlib.h' line='101' column='1'/>
      </data-member>
    </class-decl>
    <!-- class SpinLock -->
    <class-decl name='SpinLock' size-in-bits='32' visibility='default' filepath='./src/base/spinlock.h' line='48' column='1' id='type-id-82'>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__2 -->
        <enum-decl name='__anonymous_enum__2' is-anonymous='yes' filepath='./src/base/spinlock.h' line='116' column='1' id='type-id-83'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockSleeper' value='2'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__ -->
        <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='src/base/spinlock.h' line='114' column='1' id='type-id-85'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockFree' value='0'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- enum SpinLock::__anonymous_enum__1 -->
        <enum-decl name='__anonymous_enum__1' is-anonymous='yes' filepath='src/base/spinlock.h' line='115' column='1' id='type-id-86'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kSpinLockHeld' value='1'/>
        </enum-decl>
      </member-type>
      <data-member access='private' static='yes'>
        <!-- static const base::LinkerInitialized SpinLock::LINKER_INITIALIZED -->
        <var-decl name='LINKER_INITIALIZED' type-id='type-id-87' mangled-name='_ZN8SpinLock18LINKER_INITIALIZEDE' visibility='default' filepath='src/base/spinlock.h' line='112' column='1' elf-symbol-id='_ZN8SpinLock18LINKER_INITIALIZEDE'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- volatile Atomic32 SpinLock::lockword_ -->
        <var-decl name='lockword_' type-id='type-id-88' visibility='default' filepath='src/base/spinlock.h' line='118' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock() -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='50' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock(base::LinkerInitialized) -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='61' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'enum base::LinkerInitialized' -->
          <parameter type-id='type-id-90'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::Lock() -->
        <function-decl name='Lock' mangled-name='_ZN8SpinLock4LockEv' filepath='src/base/spinlock.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool SpinLock::TryLock() -->
        <function-decl name='TryLock' mangled-name='_ZN8SpinLock7TryLockEv' filepath='src/base/spinlock.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::Unlock() -->
        <function-decl name='Unlock' mangled-name='_ZN8SpinLock6UnlockEv' filepath='src/base/spinlock.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool SpinLock::IsHeld() -->
        <function-decl name='IsHeld' mangled-name='_ZNK8SpinLock6IsHeldEv' filepath='src/base/spinlock.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const SpinLock*' -->
          <parameter type-id='type-id-91' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::SlowLock() -->
        <function-decl name='SlowLock' mangled-name='_ZN8SpinLock8SlowLockEv' filepath='src/base/spinlock.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock8SlowLockEv'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::SlowUnlock(uint64) -->
        <function-decl name='SlowUnlock' mangled-name='_ZN8SpinLock10SlowUnlockEm' filepath='src/base/spinlock.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock10SlowUnlockEm'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef uint64' -->
          <parameter type-id='type-id-92'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- Atomic32 SpinLock::SpinLoop(int64, Atomic32*) -->
        <function-decl name='SpinLoop' mangled-name='_ZN8SpinLock8SpinLoopElPi' filepath='src/base/spinlock.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8SpinLock8SpinLoopElPi'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef int64' -->
          <parameter type-id='type-id-93'/>
          <!-- parameter of type 'Atomic32*' -->
          <parameter type-id='type-id-94'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- int32 SpinLock::CalculateWaitCycles(int64) -->
        <function-decl name='CalculateWaitCycles' mangled-name='_ZN8SpinLock19CalculateWaitCyclesEl' filepath='src/base/spinlock.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'typedef int64' -->
          <parameter type-id='type-id-93'/>
          <!-- typedef int32 -->
          <return type-id='type-id-69'/>
        </function-decl>
      </member-function>
      <member-function access='private' constructor='yes'>
        <!-- SpinLock::SpinLock(const SpinLock&) -->
        <function-decl name='SpinLock' filepath='src/base/spinlock.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'const SpinLock&' -->
          <parameter type-id='type-id-96'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void SpinLock::operator=(const SpinLock&) -->
        <function-decl name='operator=' mangled-name='_ZN8SpinLockaSERKS_' filepath='src/base/spinlock.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89' is-artificial='yes'/>
          <!-- parameter of type 'const SpinLock&' -->
          <parameter type-id='type-id-96'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct ldiv_t -->
    <class-decl name='ldiv_t' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/include/stdlib.h' line='107' column='1' id='type-id-1377'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- long int ldiv_t::quot -->
        <var-decl name='quot' type-id='type-id-80' visibility='default' filepath='/usr/include/stdlib.h' line='108' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- long int ldiv_t::rem -->
        <var-decl name='rem' type-id='type-id-80' visibility='default' filepath='/usr/include/stdlib.h' line='109' column='1'/>
      </data-member>
    </class-decl>
    <!-- class TCMalloc_Printer -->
    <class-decl name='TCMalloc_Printer' size-in-bits='128' visibility='default' filepath='src/internal_logging.h' line='126' column='1' id='type-id-1378'>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- char* TCMalloc_Printer::buf_ -->
        <var-decl name='buf_' type-id='type-id-113' visibility='default' filepath='src/internal_logging.h' line='128' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- int TCMalloc_Printer::left_ -->
        <var-decl name='left_' type-id='type-id-1' visibility='default' filepath='src/internal_logging.h' line='129' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- TCMalloc_Printer::TCMalloc_Printer(char*, int) -->
        <function-decl name='TCMalloc_Printer' filepath='src/internal_logging.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMalloc_Printer*' -->
          <parameter type-id='type-id-1379' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void TCMalloc_Printer::printf(const char*, ...) -->
        <function-decl name='printf' mangled-name='_ZN16TCMalloc_Printer6printfEPKcz' filepath='src/internal_logging.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN16TCMalloc_Printer6printfEPKcz'>
          <!-- implicit parameter of type 'TCMalloc_Printer*' -->
          <parameter type-id='type-id-1379' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <parameter is-variadic='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef unsigned int wint_t -->
    <typedef-decl name='wint_t' type-id='type-id-59' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/include/stddef.h' line='352' column='1' id='type-id-1380'/>
    <!-- class PackedCache<35, long unsigned int> -->
    <class-decl name='PackedCache&lt;35, long unsigned int&gt;' size-in-bits='4194304' visibility='default' filepath='src/packed-cache-inl.h' line='135' column='1' id='type-id-1381'>
      <data-member access='private' static='yes'>
        <!-- static const int PackedCache<35, long unsigned int>::kHashbits -->
        <var-decl name='kHashbits' type-id='type-id-134' visibility='default' filepath='src/packed-cache-inl.h' line='143' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int PackedCache<35, long unsigned int>::kValuebits -->
        <var-decl name='kValuebits' type-id='type-id-134' visibility='default' filepath='src/packed-cache-inl.h' line='145' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const bool PackedCache<35, long unsigned int>::kUseWholeKeys -->
        <var-decl name='kUseWholeKeys' type-id='type-id-477' visibility='default' filepath='src/packed-cache-inl.h' line='146' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int PackedCache<35, long unsigned int>::kTbits -->
        <var-decl name='kTbits' type-id='type-id-134' visibility='default' filepath='src/packed-cache-inl.h' line='220' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const int PackedCache<35, long unsigned int>::kUpperbits -->
        <var-decl name='kUpperbits' type-id='type-id-134' visibility='default' filepath='src/packed-cache-inl.h' line='221' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const uintptr_t PackedCache<35, long unsigned int>::kKeyMask -->
        <var-decl name='kKeyMask' type-id='type-id-282' visibility='default' filepath='src/packed-cache-inl.h' line='224' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const unsigned long int PackedCache<35, long unsigned int>::kUpperMask -->
        <var-decl name='kUpperMask' type-id='type-id-633' visibility='default' filepath='src/packed-cache-inl.h' line='227' column='1'/>
      </data-member>
      <data-member access='private' static='yes'>
        <!-- static const size_t PackedCache<35, long unsigned int>::kValueMask -->
        <var-decl name='kValueMask' type-id='type-id-112' visibility='default' filepath='src/packed-cache-inl.h' line='230' column='1'/>
      </data-member>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- volatile unsigned long int PackedCache<35, long unsigned int>::array_[65536] -->
        <var-decl name='array_' type-id='type-id-1365' visibility='default' filepath='src/packed-cache-inl.h' line='234' column='1'/>
      </data-member>
      <member-function access='private'>
        <!-- void PackedCache<35, long unsigned int>::PackedCache(unsigned long int) -->
        <function-decl name='PackedCache' filepath='src/packed-cache-inl.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'PackedCache<35, long unsigned int>*' -->
          <parameter type-id='type-id-1382' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void PackedCache<35, long unsigned int>::Put(unsigned long int, unsigned long int) -->
        <function-decl name='Put' mangled-name='_ZN11PackedCacheILi35EmE3PutEmm' filepath='src/packed-cache-inl.h' line='157' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'PackedCache<35, long unsigned int>*' -->
          <parameter type-id='type-id-1382' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- bool PackedCache<35, long unsigned int>::Has(unsigned long int) -->
        <function-decl name='Has' mangled-name='_ZNK11PackedCacheILi35EmE3HasEm' filepath='src/packed-cache-inl.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const PackedCache<35, long unsigned int>*' -->
          <parameter type-id='type-id-1383' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- size_t PackedCache<35, long unsigned int>::GetOrDefault(unsigned long int, unsigned long int) -->
        <function-decl name='GetOrDefault' mangled-name='_ZNK11PackedCacheILi35EmE12GetOrDefaultEmm' filepath='src/packed-cache-inl.h' line='168' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'const PackedCache<35, long unsigned int>*' -->
          <parameter type-id='type-id-1383' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void PackedCache<35, long unsigned int>::Clear(unsigned long int) -->
        <function-decl name='Clear' mangled-name='_ZN11PackedCacheILi35EmE5ClearEm' filepath='src/packed-cache-inl.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'PackedCache<35, long unsigned int>*' -->
          <parameter type-id='type-id-1382' is-artificial='yes'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- size_t PackedCache<35, long unsigned int>::EntryToValue() -->
        <function-decl name='EntryToValue' mangled-name='_ZN11PackedCacheILi35EmE12EntryToValueEm' filepath='src/packed-cache-inl.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- unsigned long int PackedCache<35, long unsigned int>::KeyToUpper() -->
        <function-decl name='KeyToUpper' mangled-name='_ZN11PackedCacheILi35EmE10KeyToUpperEm' filepath='src/packed-cache-inl.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- unsigned long int -->
          <return type-id='type-id-5'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- size_t PackedCache<35, long unsigned int>::Hash() -->
        <function-decl name='Hash' mangled-name='_ZN11PackedCacheILi35EmE4HashEm' filepath='src/packed-cache-inl.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool PackedCache<35, long unsigned int>::KeyMatch(unsigned long int) -->
        <function-decl name='KeyMatch' mangled-name='_ZN11PackedCacheILi35EmE8KeyMatchEmm' filepath='src/packed-cache-inl.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- parameter of type 'unsigned long int' -->
          <parameter type-id='type-id-5'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef _IO_FILE __FILE -->
    <typedef-decl name='__FILE' type-id='type-id-1384' filepath='/usr/include/stdio.h' line='65' column='1' id='type-id-1385'/>
    <!-- class MallocExtension -->
    <class-decl name='MallocExtension' size-in-bits='64' visibility='default' filepath='src/gperftools/malloc_extension.h' line='90' column='1' id='type-id-803'>
      <member-type access='private'>
        <!-- enum MallocExtension::Ownership -->
        <enum-decl name='Ownership' filepath='./src/gperftools/malloc_extension.h' line='315' column='1' id='type-id-867'>
          <underlying-type type-id='type-id-84'/>
          <enumerator name='kUnknownOwnership' value='0'/>
          <enumerator name='kOwned' value='1'/>
          <enumerator name='kNotOwned' value='2'/>
        </enum-decl>
      </member-type>
      <member-type access='private'>
        <!-- struct MallocExtension::FreeListInfo -->
        <class-decl name='FreeListInfo' size-in-bits='256' is-struct='yes' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='333' column='1' id='type-id-868'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- size_t MallocExtension::FreeListInfo::min_object_size -->
            <var-decl name='min_object_size' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='334' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- size_t MallocExtension::FreeListInfo::max_object_size -->
            <var-decl name='max_object_size' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='335' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='128'>
            <!-- size_t MallocExtension::FreeListInfo::total_bytes_free -->
            <var-decl name='total_bytes_free' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='336' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='192'>
            <!-- const char* MallocExtension::FreeListInfo::type -->
            <var-decl name='type' type-id='type-id-52' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='337' column='1'/>
          </data-member>
        </class-decl>
      </member-type>
      <member-type access='private'>
        <!-- typedef void (void*, const base::MallocRange*) MallocExtension::RangeFunction -->
        <typedef-decl name='RangeFunction' type-id='type-id-870' filepath='src/gperftools/malloc_extension.h' line='143' column='1' id='type-id-869'/>
      </member-type>
      <member-function access='private' static='yes'>
        <!-- void MallocExtension::Initialize() -->
        <function-decl name='Initialize' mangled-name='_ZN15MallocExtension10InitializeEv' filepath='src/malloc_extension.cc' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension10InitializeEv'>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocExtension* MallocExtension::instance() -->
        <function-decl name='instance' mangled-name='_ZN15MallocExtension8instanceEv' filepath='src/malloc_extension.cc' line='212' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8instanceEv'>
          <!-- MallocExtension* -->
          <return type-id='type-id-278'/>
        </function-decl>
      </member-function>
      <member-function access='private'>
        <!-- void MallocExtension::Register() -->
        <function-decl name='Register' mangled-name='_ZN15MallocExtension8RegisterEPS_' filepath='src/malloc_extension.cc' line='217' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8RegisterEPS_'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes' vtable-offset='-1'>
        <!-- MallocExtension::~MallocExtension(int) -->
        <function-decl name='~MallocExtension' mangled-name='_ZN15MallocExtensionD1Ev' filepath='src/malloc_extension.cc' line='111' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtensionD1Ev'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- bool MallocExtension::VerifyAllMemory() -->
        <function-decl name='VerifyAllMemory' mangled-name='_ZN15MallocExtension15VerifyAllMemoryEv' filepath='src/malloc_extension.cc' line='112' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15VerifyAllMemoryEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='3'>
        <!-- bool MallocExtension::VerifyNewMemory(void*) -->
        <function-decl name='VerifyNewMemory' mangled-name='_ZN15MallocExtension15VerifyNewMemoryEPKv' filepath='src/malloc_extension.cc' line='113' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15VerifyNewMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='4'>
        <!-- bool MallocExtension::VerifyArrayNewMemory(void*) -->
        <function-decl name='VerifyArrayNewMemory' mangled-name='_ZN15MallocExtension20VerifyArrayNewMemoryEPKv' filepath='src/malloc_extension.cc' line='114' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20VerifyArrayNewMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='5'>
        <!-- bool MallocExtension::VerifyMallocMemory(void*) -->
        <function-decl name='VerifyMallocMemory' mangled-name='_ZN15MallocExtension18VerifyMallocMemoryEPKv' filepath='src/malloc_extension.cc' line='115' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18VerifyMallocMemoryEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='6'>
        <!-- bool MallocExtension::MallocMemoryStats(int*, size_t*, int*) -->
        <function-decl name='MallocMemoryStats' mangled-name='_ZN15MallocExtension17MallocMemoryStatsEPiPmS0_' filepath='src/malloc_extension.cc' line='130' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension17MallocMemoryStatsEPiPmS0_'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='7'>
        <!-- void MallocExtension::GetStats(char*, int) -->
        <function-decl name='GetStats' mangled-name='_ZN15MallocExtension8GetStatsEPci' filepath='src/malloc_extension.cc' line='125' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension8GetStatsEPci'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='8'>
        <!-- void MallocExtension::GetHeapSample(MallocExtensionWriter*) -->
        <function-decl name='GetHeapSample' mangled-name='_ZN15MallocExtension13GetHeapSampleEPSs' filepath='src/malloc_extension.cc' line='292' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension13GetHeapSampleEPSs'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'MallocExtensionWriter*' -->
          <parameter type-id='type-id-872'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='9'>
        <!-- void MallocExtension::GetHeapGrowthStacks(MallocExtensionWriter*) -->
        <function-decl name='GetHeapGrowthStacks' mangled-name='_ZN15MallocExtension19GetHeapGrowthStacksEPSs' filepath='src/malloc_extension.cc' line='316' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension19GetHeapGrowthStacksEPSs'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'MallocExtensionWriter*' -->
          <parameter type-id='type-id-872'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='10'>
        <!-- void MallocExtension::Ranges(void*, MallocExtension::RangeFunction*) -->
        <function-decl name='Ranges' mangled-name='_ZN15MallocExtension6RangesEPvPFvS0_PKN4base11MallocRangeEE' filepath='src/malloc_extension.cc' line='340' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension6RangesEPvPFvS0_PKN4base11MallocRangeEE'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'MallocExtension::RangeFunction*' -->
          <parameter type-id='type-id-873'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='11'>
        <!-- bool MallocExtension::GetNumericProperty(const char*, size_t*) -->
        <function-decl name='GetNumericProperty' mangled-name='_ZN15MallocExtension18GetNumericPropertyEPKcPm' filepath='src/malloc_extension.cc' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18GetNumericPropertyEPKcPm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='12'>
        <!-- bool MallocExtension::SetNumericProperty(const char*, size_t) -->
        <function-decl name='SetNumericProperty' mangled-name='_ZN15MallocExtension18SetNumericPropertyEPKcm' filepath='src/malloc_extension.cc' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18SetNumericPropertyEPKcm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='13'>
        <!-- void MallocExtension::MarkThreadIdle() -->
        <function-decl name='MarkThreadIdle' mangled-name='_ZN15MallocExtension14MarkThreadIdleEv' filepath='src/malloc_extension.cc' line='146' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension14MarkThreadIdleEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='14'>
        <!-- void MallocExtension::MarkThreadBusy() -->
        <function-decl name='MarkThreadBusy' mangled-name='_ZN15MallocExtension14MarkThreadBusyEv' filepath='src/malloc_extension.cc' line='150' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension14MarkThreadBusyEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='15'>
        <!-- SysAllocator* MallocExtension::GetSystemAllocator() -->
        <function-decl name='GetSystemAllocator' mangled-name='_ZN15MallocExtension18GetSystemAllocatorEv' filepath='src/malloc_extension.cc' line='154' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18GetSystemAllocatorEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- SysAllocator* -->
          <return type-id='type-id-874'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='16'>
        <!-- void MallocExtension::SetSystemAllocator(SysAllocator*) -->
        <function-decl name='SetSystemAllocator' mangled-name='_ZN15MallocExtension18SetSystemAllocatorEP12SysAllocator' filepath='src/malloc_extension.cc' line='158' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension18SetSystemAllocatorEP12SysAllocator'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='17'>
        <!-- void MallocExtension::ReleaseToSystem(size_t) -->
        <function-decl name='ReleaseToSystem' mangled-name='_ZN15MallocExtension15ReleaseToSystemEm' filepath='src/malloc_extension.cc' line='162' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15ReleaseToSystemEm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='18'>
        <!-- void MallocExtension::ReleaseFreeMemory() -->
        <function-decl name='ReleaseFreeMemory' mangled-name='_ZN15MallocExtension17ReleaseFreeMemoryEv' filepath='src/malloc_extension.cc' line='166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension17ReleaseFreeMemoryEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='19'>
        <!-- void MallocExtension::SetMemoryReleaseRate(double) -->
        <function-decl name='SetMemoryReleaseRate' mangled-name='_ZN15MallocExtension20SetMemoryReleaseRateEd' filepath='src/malloc_extension.cc' line='170' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20SetMemoryReleaseRateEd'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'double' -->
          <parameter type-id='type-id-2'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='20'>
        <!-- double MallocExtension::GetMemoryReleaseRate() -->
        <function-decl name='GetMemoryReleaseRate' mangled-name='_ZN15MallocExtension20GetMemoryReleaseRateEv' filepath='src/malloc_extension.cc' line='174' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension20GetMemoryReleaseRateEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- double -->
          <return type-id='type-id-2'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='21'>
        <!-- size_t MallocExtension::GetEstimatedAllocatedSize(size_t) -->
        <function-decl name='GetEstimatedAllocatedSize' mangled-name='_ZN15MallocExtension25GetEstimatedAllocatedSizeEm' filepath='src/malloc_extension.cc' line='178' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension25GetEstimatedAllocatedSizeEm'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='22'>
        <!-- size_t MallocExtension::GetAllocatedSize(void*) -->
        <function-decl name='GetAllocatedSize' mangled-name='_ZN15MallocExtension16GetAllocatedSizeEPKv' filepath='src/malloc_extension.cc' line='182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension16GetAllocatedSizeEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='23'>
        <!-- MallocExtension::Ownership MallocExtension::GetOwnership(void*) -->
        <function-decl name='GetOwnership' mangled-name='_ZN15MallocExtension12GetOwnershipEPKv' filepath='src/malloc_extension.cc' line='187' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension12GetOwnershipEPKv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- enum MallocExtension::Ownership -->
          <return type-id='type-id-867'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='24'>
        <!-- void MallocExtension::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*) -->
        <function-decl name='GetFreeListSizes' mangled-name='_ZN15MallocExtension16GetFreeListSizesEPSt6vectorINS_12FreeListInfoESaIS1_EE' filepath='src/malloc_extension.cc' line='191' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension16GetFreeListSizesEPSt6vectorINS_12FreeListInfoESaIS1_EE'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
          <parameter type-id='type-id-875'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='25'>
        <!-- void** MallocExtension::ReadStackTraces(int*) -->
        <function-decl name='ReadStackTraces' mangled-name='_ZN15MallocExtension15ReadStackTracesEPi' filepath='src/malloc_extension.cc' line='138' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension15ReadStackTracesEPi'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='26'>
        <!-- void** MallocExtension::ReadHeapGrowthStackTraces() -->
        <function-decl name='ReadHeapGrowthStackTraces' mangled-name='_ZN15MallocExtension25ReadHeapGrowthStackTracesEv' filepath='src/malloc_extension.cc' line='142' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN15MallocExtension25ReadHeapGrowthStackTracesEv'>
          <!-- implicit parameter of type 'MallocExtension*' -->
          <parameter type-id='type-id-278' is-artificial='yes'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct _IO_FILE -->
    <class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' filepath='/usr/include/libio.h' line='271' column='1' id='type-id-1384'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int _IO_FILE::_flags -->
        <var-decl name='_flags' type-id='type-id-1' visibility='default' filepath='/usr/include/libio.h' line='272' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- char* _IO_FILE::_IO_read_ptr -->
        <var-decl name='_IO_read_ptr' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='277' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- char* _IO_FILE::_IO_read_end -->
        <var-decl name='_IO_read_end' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='278' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- char* _IO_FILE::_IO_read_base -->
        <var-decl name='_IO_read_base' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='279' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- char* _IO_FILE::_IO_write_base -->
        <var-decl name='_IO_write_base' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='280' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- char* _IO_FILE::_IO_write_ptr -->
        <var-decl name='_IO_write_ptr' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='281' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- char* _IO_FILE::_IO_write_end -->
        <var-decl name='_IO_write_end' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='282' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='448'>
        <!-- char* _IO_FILE::_IO_buf_base -->
        <var-decl name='_IO_buf_base' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='283' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='512'>
        <!-- char* _IO_FILE::_IO_buf_end -->
        <var-decl name='_IO_buf_end' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='284' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='576'>
        <!-- char* _IO_FILE::_IO_save_base -->
        <var-decl name='_IO_save_base' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='286' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='640'>
        <!-- char* _IO_FILE::_IO_backup_base -->
        <var-decl name='_IO_backup_base' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='287' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='704'>
        <!-- char* _IO_FILE::_IO_save_end -->
        <var-decl name='_IO_save_end' type-id='type-id-113' visibility='default' filepath='/usr/include/libio.h' line='288' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='768'>
        <!-- _IO_marker* _IO_FILE::_markers -->
        <var-decl name='_markers' type-id='type-id-1386' visibility='default' filepath='/usr/include/libio.h' line='290' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='832'>
        <!-- _IO_FILE* _IO_FILE::_chain -->
        <var-decl name='_chain' type-id='type-id-1387' visibility='default' filepath='/usr/include/libio.h' line='292' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='896'>
        <!-- int _IO_FILE::_fileno -->
        <var-decl name='_fileno' type-id='type-id-1' visibility='default' filepath='/usr/include/libio.h' line='294' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='928'>
        <!-- int _IO_FILE::_flags2 -->
        <var-decl name='_flags2' type-id='type-id-1' visibility='default' filepath='/usr/include/libio.h' line='298' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='960'>
        <!-- __off_t _IO_FILE::_old_offset -->
        <var-decl name='_old_offset' type-id='type-id-305' visibility='default' filepath='/usr/include/libio.h' line='300' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1024'>
        <!-- unsigned short int _IO_FILE::_cur_column -->
        <var-decl name='_cur_column' type-id='type-id-14' visibility='default' filepath='/usr/include/libio.h' line='304' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1040'>
        <!-- signed char _IO_FILE::_vtable_offset -->
        <var-decl name='_vtable_offset' type-id='type-id-1349' visibility='default' filepath='/usr/include/libio.h' line='305' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1048'>
        <!-- char _IO_FILE::_shortbuf[1] -->
        <var-decl name='_shortbuf' type-id='type-id-1338' visibility='default' filepath='/usr/include/libio.h' line='306' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1088'>
        <!-- _IO_lock_t* _IO_FILE::_lock -->
        <var-decl name='_lock' type-id='type-id-1388' visibility='default' filepath='/usr/include/libio.h' line='310' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1152'>
        <!-- __off64_t _IO_FILE::_offset -->
        <var-decl name='_offset' type-id='type-id-1079' visibility='default' filepath='/usr/include/libio.h' line='319' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1216'>
        <!-- void* _IO_FILE::__pad1 -->
        <var-decl name='__pad1' type-id='type-id-53' visibility='default' filepath='/usr/include/libio.h' line='328' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1280'>
        <!-- void* _IO_FILE::__pad2 -->
        <var-decl name='__pad2' type-id='type-id-53' visibility='default' filepath='/usr/include/libio.h' line='329' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1344'>
        <!-- void* _IO_FILE::__pad3 -->
        <var-decl name='__pad3' type-id='type-id-53' visibility='default' filepath='/usr/include/libio.h' line='330' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1408'>
        <!-- void* _IO_FILE::__pad4 -->
        <var-decl name='__pad4' type-id='type-id-53' visibility='default' filepath='/usr/include/libio.h' line='331' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1472'>
        <!-- size_t _IO_FILE::__pad5 -->
        <var-decl name='__pad5' type-id='type-id-57' visibility='default' filepath='/usr/include/libio.h' line='332' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1536'>
        <!-- int _IO_FILE::_mode -->
        <var-decl name='_mode' type-id='type-id-1' visibility='default' filepath='/usr/include/libio.h' line='334' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='1568'>
        <!-- char _IO_FILE::_unused2[20] -->
        <var-decl name='_unused2' type-id='type-id-1340' visibility='default' filepath='/usr/include/libio.h' line='336' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct _IO_marker -->
    <class-decl name='_IO_marker' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/include/libio.h' line='186' column='1' id='type-id-1389'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- _IO_marker* _IO_marker::_next -->
        <var-decl name='_next' type-id='type-id-1386' visibility='default' filepath='/usr/include/libio.h' line='187' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- _IO_FILE* _IO_marker::_sbuf -->
        <var-decl name='_sbuf' type-id='type-id-1387' visibility='default' filepath='/usr/include/libio.h' line='188' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- int _IO_marker::_pos -->
        <var-decl name='_pos' type-id='type-id-1' visibility='default' filepath='/usr/include/libio.h' line='192' column='1'/>
      </data-member>
    </class-decl>
    <!-- class SysAllocator -->
    <class-decl name='SysAllocator' size-in-bits='64' visibility='default' filepath='src/gperftools/malloc_extension.h' line='75' column='1' id='type-id-929'>
      <member-function access='private' constructor='yes'>
        <!-- SysAllocator::SysAllocator() -->
        <function-decl name='SysAllocator' filepath='./src/gperftools/malloc_extension.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes' vtable-offset='-1'>
        <!-- SysAllocator::~SysAllocator(int) -->
        <function-decl name='~SysAllocator' mangled-name='_ZN12SysAllocatorD1Ev' filepath='src/malloc_extension.cc' line='108' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN12SysAllocatorD1Ev'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='2'>
        <!-- void* SysAllocator::Alloc(size_t, size_t*, size_t) -->
        <function-decl name='Alloc' mangled-name='_ZN12SysAllocator5AllocEmPmm' filepath='src/gperftools/malloc_extension.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef long int __off_t -->
    <typedef-decl name='__off_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='141' column='1' id='type-id-305'/>
    <!-- typedef void _IO_lock_t -->
    <typedef-decl name='_IO_lock_t' type-id='type-id-56' filepath='/usr/include/libio.h' line='180' column='1' id='type-id-1390'/>
    <!-- typedef long int __off64_t -->
    <typedef-decl name='__off64_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='142' column='1' id='type-id-1079'/>
    <!-- typedef __mbstate_t mbstate_t -->
    <typedef-decl name='mbstate_t' type-id='type-id-1391' filepath='/usr/include/wchar.h' line='106' column='1' id='type-id-1392'/>
    <!-- struct __mbstate_t -->
    <class-decl name='__mbstate_t' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/include/wchar.h' line='84' column='1' id='type-id-1391'>
      <member-type access='public'>
        <!-- union {unsigned int __wch; char __wchb[4];} -->
        <union-decl name='__anonymous_union__' size-in-bits='32' is-anonymous='yes' visibility='default' filepath='/usr/include/wchar.h' line='87' column='1' id='type-id-1393'>
          <data-member access='private'>
            <!-- unsigned int __wch -->
            <var-decl name='__wch' type-id='type-id-59' visibility='default' filepath='/usr/include/wchar.h' line='89' column='1'/>
          </data-member>
          <data-member access='private'>
            <!-- char __wchb[4] -->
            <var-decl name='__wchb' type-id='type-id-1341' visibility='default' filepath='/usr/include/wchar.h' line='93' column='1'/>
          </data-member>
        </union-decl>
      </member-type>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int __mbstate_t::__count -->
        <var-decl name='__count' type-id='type-id-1' visibility='default' filepath='/usr/include/wchar.h' line='85' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- union {unsigned int __wch; char __wchb[4];} __mbstate_t::__value -->
        <var-decl name='__value' type-id='type-id-1393' visibility='default' filepath='/usr/include/wchar.h' line='94' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct tm -->
    <class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' filepath='/usr/include/time.h' line='134' column='1' id='type-id-1394'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int tm::tm_sec -->
        <var-decl name='tm_sec' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='135' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int tm::tm_min -->
        <var-decl name='tm_min' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='136' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int tm::tm_hour -->
        <var-decl name='tm_hour' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='137' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='96'>
        <!-- int tm::tm_mday -->
        <var-decl name='tm_mday' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='138' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- int tm::tm_mon -->
        <var-decl name='tm_mon' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='139' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='160'>
        <!-- int tm::tm_year -->
        <var-decl name='tm_year' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='140' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- int tm::tm_wday -->
        <var-decl name='tm_wday' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='141' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='224'>
        <!-- int tm::tm_yday -->
        <var-decl name='tm_yday' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='142' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- int tm::tm_isdst -->
        <var-decl name='tm_isdst' type-id='type-id-1' visibility='default' filepath='/usr/include/time.h' line='143' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- long int tm::tm_gmtoff -->
        <var-decl name='tm_gmtoff' type-id='type-id-80' visibility='default' filepath='/usr/include/time.h' line='146' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- const char* tm::tm_zone -->
        <var-decl name='tm_zone' type-id='type-id-52' visibility='default' filepath='/usr/include/time.h' line='147' column='1'/>
      </data-member>
    </class-decl>
    <!-- struct lconv -->
    <class-decl name='lconv' size-in-bits='768' is-struct='yes' visibility='default' filepath='/usr/include/locale.h' line='55' column='1' id='type-id-1395'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- char* lconv::decimal_point -->
        <var-decl name='decimal_point' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='58' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- char* lconv::thousands_sep -->
        <var-decl name='thousands_sep' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='59' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- char* lconv::grouping -->
        <var-decl name='grouping' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='65' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- char* lconv::int_curr_symbol -->
        <var-decl name='int_curr_symbol' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='71' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- char* lconv::currency_symbol -->
        <var-decl name='currency_symbol' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='72' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='320'>
        <!-- char* lconv::mon_decimal_point -->
        <var-decl name='mon_decimal_point' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='73' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='384'>
        <!-- char* lconv::mon_thousands_sep -->
        <var-decl name='mon_thousands_sep' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='74' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='448'>
        <!-- char* lconv::mon_grouping -->
        <var-decl name='mon_grouping' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='75' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='512'>
        <!-- char* lconv::positive_sign -->
        <var-decl name='positive_sign' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='76' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='576'>
        <!-- char* lconv::negative_sign -->
        <var-decl name='negative_sign' type-id='type-id-113' visibility='default' filepath='/usr/include/locale.h' line='77' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='640'>
        <!-- char lconv::int_frac_digits -->
        <var-decl name='int_frac_digits' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='78' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='648'>
        <!-- char lconv::frac_digits -->
        <var-decl name='frac_digits' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='79' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='656'>
        <!-- char lconv::p_cs_precedes -->
        <var-decl name='p_cs_precedes' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='81' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='664'>
        <!-- char lconv::p_sep_by_space -->
        <var-decl name='p_sep_by_space' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='83' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='672'>
        <!-- char lconv::n_cs_precedes -->
        <var-decl name='n_cs_precedes' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='85' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='680'>
        <!-- char lconv::n_sep_by_space -->
        <var-decl name='n_sep_by_space' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='87' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='688'>
        <!-- char lconv::p_sign_posn -->
        <var-decl name='p_sign_posn' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='94' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='696'>
        <!-- char lconv::n_sign_posn -->
        <var-decl name='n_sign_posn' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='95' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='704'>
        <!-- char lconv::int_p_cs_precedes -->
        <var-decl name='int_p_cs_precedes' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='98' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='712'>
        <!-- char lconv::int_p_sep_by_space -->
        <var-decl name='int_p_sep_by_space' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='100' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='720'>
        <!-- char lconv::int_n_cs_precedes -->
        <var-decl name='int_n_cs_precedes' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='102' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='728'>
        <!-- char lconv::int_n_sep_by_space -->
        <var-decl name='int_n_sep_by_space' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='104' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='736'>
        <!-- char lconv::int_p_sign_posn -->
        <var-decl name='int_p_sign_posn' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='111' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='744'>
        <!-- char lconv::int_n_sign_posn -->
        <var-decl name='int_n_sign_posn' type-id='type-id-60' visibility='default' filepath='/usr/include/locale.h' line='112' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef int32_t Atomic32 -->
    <typedef-decl name='Atomic32' type-id='type-id-71' filepath='./src/base/atomicops-internals-x86.h' line='43' column='1' id='type-id-95'/>
    <!-- typedef int int32_t -->
    <typedef-decl name='int32_t' type-id='type-id-1' filepath='/usr/include/stdint.h' line='39' column='1' id='type-id-71'/>
    <!-- typedef long int int64_t -->
    <typedef-decl name='int64_t' type-id='type-id-80' filepath='/usr/include/stdint.h' line='41' column='1' id='type-id-98'/>
    <!-- typedef unsigned long int uint64_t -->
    <typedef-decl name='uint64_t' type-id='type-id-5' filepath='/usr/include/stdint.h' line='56' column='1' id='type-id-15'/>
    <!-- typedef uintptr_t Length -->
    <typedef-decl name='Length' type-id='type-id-145' filepath='src/common.h' line='59' column='1' id='type-id-143'/>
    <!-- typedef unsigned long int uintptr_t -->
    <typedef-decl name='uintptr_t' type-id='type-id-5' filepath='/usr/include/stdint.h' line='123' column='1' id='type-id-145'/>
    <!-- typedef uint64_t uint64 -->
    <typedef-decl name='uint64' type-id='type-id-15' filepath='src/base/basictypes.h' line='72' column='1' id='type-id-92'/>
    <!-- typedef int64_t int64 -->
    <typedef-decl name='int64' type-id='type-id-98' filepath='src/base/basictypes.h' line='61' column='1' id='type-id-93'/>
    <!-- typedef int32_t int32 -->
    <typedef-decl name='int32' type-id='type-id-71' filepath='src/base/basictypes.h' line='60' column='1' id='type-id-69'/>
    <!-- typedef uintptr_t PageID -->
    <typedef-decl name='PageID' type-id='type-id-145' filepath='src/common.h' line='56' column='1' id='type-id-142'/>
    <!-- class SpinLockHolder -->
    <class-decl name='SpinLockHolder' size-in-bits='64' visibility='default' filepath='src/base/spinlock.h' line='130' column='1' id='type-id-1396'>
      <data-member access='private' layout-offset-in-bits='0'>
        <!-- SpinLock* SpinLockHolder::lock_ -->
        <var-decl name='lock_' type-id='type-id-89' visibility='default' filepath='src/base/spinlock.h' line='132' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- SpinLockHolder::SpinLockHolder(SpinLock*) -->
        <function-decl name='SpinLockHolder' mangled-name='_ZN14SpinLockHolderC2EP8SpinLock' filepath='src/base/spinlock.h' line='134' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14SpinLockHolderC2EP8SpinLock'>
          <!-- implicit parameter of type 'SpinLockHolder*' -->
          <parameter type-id='type-id-1397' is-artificial='yes'/>
          <!-- parameter of type 'SpinLock*' -->
          <parameter type-id='type-id-89'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- SpinLockHolder::~SpinLockHolder(int) -->
        <function-decl name='~SpinLockHolder' mangled-name='_ZN14SpinLockHolderD1Ev' filepath='src/base/spinlock.h' line='140' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN14SpinLockHolderD1Ev'>
          <!-- implicit parameter of type 'SpinLockHolder*' -->
          <parameter type-id='type-id-1397' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- class MallocHook -->
    <class-decl name='MallocHook' size-in-bits='8' visibility='default' filepath='./src/gperftools/malloc_hook.h' line='98' column='1' id='type-id-1398'>
      <member-type access='private'>
        <!-- typedef MallocHook_PreMmapHook MallocHook::PreMmapHook -->
        <typedef-decl name='PreMmapHook' type-id='type-id-1033' filepath='./src/gperftools/malloc_hook.h' line='126' column='1' id='type-id-1399'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_MmapReplacement MallocHook::MmapReplacement -->
        <typedef-decl name='MmapReplacement' type-id='type-id-1035' filepath='./src/gperftools/malloc_hook.h' line='150' column='1' id='type-id-1400'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_MunmapReplacement MallocHook::MunmapReplacement -->
        <typedef-decl name='MunmapReplacement' type-id='type-id-1037' filepath='./src/gperftools/malloc_hook.h' line='192' column='1' id='type-id-1401'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_MunmapHook MallocHook::MunmapHook -->
        <typedef-decl name='MunmapHook' type-id='type-id-1038' filepath='./src/gperftools/malloc_hook.h' line='204' column='1' id='type-id-1402'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_MremapHook MallocHook::MremapHook -->
        <typedef-decl name='MremapHook' type-id='type-id-1040' filepath='./src/gperftools/malloc_hook.h' line='214' column='1' id='type-id-1403'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_PreSbrkHook MallocHook::PreSbrkHook -->
        <typedef-decl name='PreSbrkHook' type-id='type-id-1042' filepath='./src/gperftools/malloc_hook.h' line='234' column='1' id='type-id-1404'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_NewHook MallocHook::NewHook -->
        <typedef-decl name='NewHook' type-id='type-id-382' filepath='./src/gperftools/malloc_hook.h' line='102' column='1' id='type-id-1405'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_DeleteHook MallocHook::DeleteHook -->
        <typedef-decl name='DeleteHook' type-id='type-id-383' filepath='./src/gperftools/malloc_hook.h' line='113' column='1' id='type-id-1406'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_MmapHook MallocHook::MmapHook -->
        <typedef-decl name='MmapHook' type-id='type-id-385' filepath='./src/gperftools/malloc_hook.h' line='168' column='1' id='type-id-1407'/>
      </member-type>
      <member-type access='private'>
        <!-- typedef MallocHook_SbrkHook MallocHook::SbrkHook -->
        <typedef-decl name='SbrkHook' type-id='type-id-387' filepath='./src/gperftools/malloc_hook.h' line='247' column='1' id='type-id-1408'/>
      </member-type>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeNewHook(size_t) -->
        <function-decl name='InvokeNewHook' mangled-name='_ZN10MallocHook13InvokeNewHookEPKvm' filepath='./src/gperftools/malloc_hook.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeDeleteHook() -->
        <function-decl name='InvokeDeleteHook' mangled-name='_ZN10MallocHook16InvokeDeleteHookEPKv' filepath='./src/gperftools/malloc_hook.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddNewHook() -->
        <function-decl name='AddNewHook' mangled-name='_ZN10MallocHook10AddNewHookEPFvPKvmE' filepath='./src/gperftools/malloc_hook.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::NewHook' -->
          <parameter type-id='type-id-1405'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveNewHook() -->
        <function-decl name='RemoveNewHook' mangled-name='_ZN10MallocHook13RemoveNewHookEPFvPKvmE' filepath='./src/gperftools/malloc_hook.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::NewHook' -->
          <parameter type-id='type-id-1405'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddDeleteHook() -->
        <function-decl name='AddDeleteHook' mangled-name='_ZN10MallocHook13AddDeleteHookEPFvPKvE' filepath='./src/gperftools/malloc_hook.h' line='114' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::DeleteHook' -->
          <parameter type-id='type-id-1406'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveDeleteHook() -->
        <function-decl name='RemoveDeleteHook' mangled-name='_ZN10MallocHook16RemoveDeleteHookEPFvPKvE' filepath='./src/gperftools/malloc_hook.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::DeleteHook' -->
          <parameter type-id='type-id-1406'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::NewHook MallocHook::GetNewHook() -->
        <function-decl name='GetNewHook' mangled-name='_ZN10MallocHook10GetNewHookEv' filepath='./src/gperftools/malloc_hook.h' line='275' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- typedef MallocHook::NewHook -->
          <return type-id='type-id-1405'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::NewHook MallocHook::SetNewHook() -->
        <function-decl name='SetNewHook' mangled-name='_ZN10MallocHook10SetNewHookEPFvPKvmE' filepath='./src/gperftools/malloc_hook.h' line='276' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::NewHook' -->
          <parameter type-id='type-id-1405'/>
          <!-- typedef MallocHook::NewHook -->
          <return type-id='type-id-1405'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::DeleteHook MallocHook::GetDeleteHook() -->
        <function-decl name='GetDeleteHook' mangled-name='_ZN10MallocHook13GetDeleteHookEv' filepath='./src/gperftools/malloc_hook.h' line='280' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- typedef MallocHook::DeleteHook -->
          <return type-id='type-id-1406'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::DeleteHook MallocHook::SetDeleteHook() -->
        <function-decl name='SetDeleteHook' mangled-name='_ZN10MallocHook13SetDeleteHookEPFvPKvE' filepath='./src/gperftools/malloc_hook.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::DeleteHook' -->
          <parameter type-id='type-id-1406'/>
          <!-- typedef MallocHook::DeleteHook -->
          <return type-id='type-id-1406'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::MmapHook MallocHook::GetMmapHook() -->
        <function-decl name='GetMmapHook' mangled-name='_ZN10MallocHook11GetMmapHookEv' filepath='./src/gperftools/malloc_hook.h' line='290' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- typedef MallocHook::MmapHook -->
          <return type-id='type-id-1407'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- MallocHook::SbrkHook MallocHook::GetSbrkHook() -->
        <function-decl name='GetSbrkHook' mangled-name='_ZN10MallocHook11GetSbrkHookEv' filepath='./src/gperftools/malloc_hook.h' line='310' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- typedef MallocHook::SbrkHook -->
          <return type-id='type-id-1408'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemovePreMmapHook() -->
        <function-decl name='RemovePreMmapHook' mangled-name='_ZN10MallocHook17RemovePreMmapHookEPFvPKvmiiilE' filepath='./src/gperftools/malloc_hook.h' line='130' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::PreMmapHook' -->
          <parameter type-id='type-id-1399'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokePreMmapHook(size_t, int, int, int, off_t) -->
        <function-decl name='InvokePreMmapHook' mangled-name='_ZN10MallocHook17InvokePreMmapHookEPKvmiiil' filepath='./src/gperftools/malloc_hook.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::InvokeMmapReplacement(size_t, int, int, int, off_t, void**) -->
        <function-decl name='InvokeMmapReplacement' mangled-name='_ZN10MallocHook21InvokeMmapReplacementEPKvmiiilPPv' filepath='./src/gperftools/malloc_hook.h' line='157' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMmapHook(void*, size_t, int, int, int, off_t) -->
        <function-decl name='InvokeMmapHook' mangled-name='_ZN10MallocHook14InvokeMmapHookEPKvS1_miiil' filepath='./src/gperftools/malloc_hook.h' line='175' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::InvokeMunmapReplacement(size_t, int*) -->
        <function-decl name='InvokeMunmapReplacement' mangled-name='_ZN10MallocHook23InvokeMunmapReplacementEPKvmPi' filepath='./src/gperftools/malloc_hook.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMunmapHook(size_t) -->
        <function-decl name='InvokeMunmapHook' mangled-name='_ZN10MallocHook16InvokeMunmapHookEPKvm' filepath='./src/gperftools/malloc_hook.h' line='211' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMremapHook(void*, size_t, size_t, int, void*) -->
        <function-decl name='InvokeMremapHook' mangled-name='_ZN10MallocHook16InvokeMremapHookEPKvS1_mmiS1_' filepath='./src/gperftools/malloc_hook.h' line='221' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemovePreSbrkHook() -->
        <function-decl name='RemovePreSbrkHook' mangled-name='_ZN10MallocHook17RemovePreSbrkHookEPFvlE' filepath='./src/gperftools/malloc_hook.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::PreSbrkHook' -->
          <parameter type-id='type-id-1404'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokePreSbrkHook() -->
        <function-decl name='InvokePreSbrkHook' mangled-name='_ZN10MallocHook17InvokePreSbrkHookEl' filepath='./src/gperftools/malloc_hook.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef ptrdiff_t' -->
          <parameter type-id='type-id-208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeSbrkHook(ptrdiff_t) -->
        <function-decl name='InvokeSbrkHook' mangled-name='_ZN10MallocHook14InvokeSbrkHookEPKvl' filepath='./src/gperftools/malloc_hook.h' line='254' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef ptrdiff_t' -->
          <parameter type-id='type-id-208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void* MallocHook::UnhookedMMap(size_t, int, int, int, off_t) -->
        <function-decl name='UnhookedMMap' mangled-name='_ZN10MallocHook12UnhookedMMapEPvmiiil' filepath='./src/gperftools/malloc_hook.h' line='270' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook12UnhookedMMapEPvmiiil'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void* -->
          <return type-id='type-id-53'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int MallocHook::UnhookedMUnmap(size_t) -->
        <function-decl name='UnhookedMUnmap' mangled-name='_ZN10MallocHook14UnhookedMUnmapEPvm' filepath='./src/gperftools/malloc_hook.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook14UnhookedMUnmapEPvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeNewHookSlow(size_t) -->
        <function-decl name='InvokeNewHookSlow' mangled-name='_ZN10MallocHook17InvokeNewHookSlowEPKvm' filepath='./src/gperftools/malloc_hook.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook17InvokeNewHookSlowEPKvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeDeleteHookSlow() -->
        <function-decl name='InvokeDeleteHookSlow' mangled-name='_ZN10MallocHook20InvokeDeleteHookSlowEPKv' filepath='./src/gperftools/malloc_hook.h' line='319' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook20InvokeDeleteHookSlowEPKv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokePreMmapHookSlow(size_t, int, int, int, off_t) -->
        <function-decl name='InvokePreMmapHookSlow' mangled-name='_ZN10MallocHook21InvokePreMmapHookSlowEPKvmiiil' filepath='./src/gperftools/malloc_hook.h' line='320' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook21InvokePreMmapHookSlowEPKvmiiil'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMmapHookSlow(void*, size_t, int, int, int, off_t) -->
        <function-decl name='InvokeMmapHookSlow' mangled-name='_ZN10MallocHook18InvokeMmapHookSlowEPKvS1_miiil' filepath='./src/gperftools/malloc_hook.h' line='326' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook18InvokeMmapHookSlowEPKvS1_miiil'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::InvokeMmapReplacementSlow(size_t, int, int, int, off_t, void**) -->
        <function-decl name='InvokeMmapReplacementSlow' mangled-name='_ZN10MallocHook25InvokeMmapReplacementSlowEPKvmiiilPPv' filepath='./src/gperftools/malloc_hook.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook25InvokeMmapReplacementSlowEPKvmiiilPPv'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'typedef off_t' -->
          <parameter type-id='type-id-207'/>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMunmapHookSlow(size_t) -->
        <function-decl name='InvokeMunmapHookSlow' mangled-name='_ZN10MallocHook20InvokeMunmapHookSlowEPKvm' filepath='./src/gperftools/malloc_hook.h' line='340' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook20InvokeMunmapHookSlowEPKvm'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::InvokeMunmapReplacementSlow(size_t, int*) -->
        <function-decl name='InvokeMunmapReplacementSlow' mangled-name='_ZN10MallocHook27InvokeMunmapReplacementSlowEPKvmPi' filepath='./src/gperftools/malloc_hook.h' line='341' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook27InvokeMunmapReplacementSlowEPKvmPi'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeMremapHookSlow(void*, size_t, size_t, int, void*) -->
        <function-decl name='InvokeMremapHookSlow' mangled-name='_ZN10MallocHook20InvokeMremapHookSlowEPKvS1_mmiS1_' filepath='./src/gperftools/malloc_hook.h' line='344' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook20InvokeMremapHookSlowEPKvS1_mmiS1_'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokePreSbrkHookSlow() -->
        <function-decl name='InvokePreSbrkHookSlow' mangled-name='_ZN10MallocHook21InvokePreSbrkHookSlowEl' filepath='./src/gperftools/malloc_hook.h' line='350' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook21InvokePreSbrkHookSlowEl'>
          <!-- parameter of type 'typedef ptrdiff_t' -->
          <parameter type-id='type-id-208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- void MallocHook::InvokeSbrkHookSlow(ptrdiff_t) -->
        <function-decl name='InvokeSbrkHookSlow' mangled-name='_ZN10MallocHook18InvokeSbrkHookSlowEPKvl' filepath='./src/gperftools/malloc_hook.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN10MallocHook18InvokeSbrkHookSlowEPKvl'>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'typedef ptrdiff_t' -->
          <parameter type-id='type-id-208'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- int MallocHook::GetCallerStackTrace(int, int) -->
        <function-decl name='GetCallerStackTrace' mangled-name='_ZN10MallocHook19GetCallerStackTraceEPPvii' filepath='./src/gperftools/malloc_hook.h' line='261' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'void**' -->
          <parameter type-id='type-id-141'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- int -->
          <return type-id='type-id-1'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddMmapHook() -->
        <function-decl name='AddMmapHook' mangled-name='_ZN10MallocHook11AddMmapHookEPFvPKvS1_miiilE' filepath='./src/gperftools/malloc_hook.h' line='169' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MmapHook' -->
          <parameter type-id='type-id-1407'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveMmapHook() -->
        <function-decl name='RemoveMmapHook' mangled-name='_ZN10MallocHook14RemoveMmapHookEPFvPKvS1_miiilE' filepath='./src/gperftools/malloc_hook.h' line='172' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MmapHook' -->
          <parameter type-id='type-id-1407'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddMunmapHook() -->
        <function-decl name='AddMunmapHook' mangled-name='_ZN10MallocHook13AddMunmapHookEPFvPKvmE' filepath='./src/gperftools/malloc_hook.h' line='205' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MunmapHook' -->
          <parameter type-id='type-id-1402'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveMunmapHook() -->
        <function-decl name='RemoveMunmapHook' mangled-name='_ZN10MallocHook16RemoveMunmapHookEPFvPKvmE' filepath='./src/gperftools/malloc_hook.h' line='208' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MunmapHook' -->
          <parameter type-id='type-id-1402'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddMremapHook() -->
        <function-decl name='AddMremapHook' mangled-name='_ZN10MallocHook13AddMremapHookEPFvPKvS1_mmiS1_E' filepath='./src/gperftools/malloc_hook.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MremapHook' -->
          <parameter type-id='type-id-1403'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveMremapHook() -->
        <function-decl name='RemoveMremapHook' mangled-name='_ZN10MallocHook16RemoveMremapHookEPFvPKvS1_mmiS1_E' filepath='./src/gperftools/malloc_hook.h' line='218' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::MremapHook' -->
          <parameter type-id='type-id-1403'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::AddSbrkHook() -->
        <function-decl name='AddSbrkHook' mangled-name='_ZN10MallocHook11AddSbrkHookEPFvPKvlE' filepath='./src/gperftools/malloc_hook.h' line='248' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::SbrkHook' -->
          <parameter type-id='type-id-1408'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' static='yes'>
        <!-- bool MallocHook::RemoveSbrkHook() -->
        <function-decl name='RemoveSbrkHook' mangled-name='_ZN10MallocHook14RemoveSbrkHookEPFvPKvlE' filepath='./src/gperftools/malloc_hook.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'typedef MallocHook::SbrkHook' -->
          <parameter type-id='type-id-1408'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef unsigned int uint32_t -->
    <typedef-decl name='uint32_t' type-id='type-id-59' filepath='/usr/include/stdint.h' line='52' column='1' id='type-id-12'/>
    <!-- typedef unsigned int pthread_key_t -->
    <typedef-decl name='pthread_key_t' type-id='type-id-59' filepath='/usr/include/bits/pthreadtypes.h' line='140' column='1' id='type-id-1089'/>
    <!-- typedef __ssize_t ssize_t -->
    <typedef-decl name='ssize_t' type-id='type-id-854' filepath='/usr/include/stdio.h' line='103' column='1' id='type-id-274'/>
    <!-- typedef long int __ssize_t -->
    <typedef-decl name='__ssize_t' type-id='type-id-80' filepath='/usr/include/bits/types.h' line='180' column='1' id='type-id-854'/>
    <!-- typedef unsigned long int pthread_t -->
    <typedef-decl name='pthread_t' type-id='type-id-5' filepath='/usr/include/bits/pthreadtypes.h' line='50' column='1' id='type-id-199'/>
    <!-- struct TCMallocStats -->
    <class-decl name='TCMallocStats' size-in-bits='512' is-struct='yes' visibility='default' filepath='src/tcmalloc.cc' line='295' column='1' id='type-id-1409'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- uint64_t TCMallocStats::thread_bytes -->
        <var-decl name='thread_bytes' type-id='type-id-15' visibility='default' filepath='src/tcmalloc.cc' line='296' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- uint64_t TCMallocStats::central_bytes -->
        <var-decl name='central_bytes' type-id='type-id-15' visibility='default' filepath='src/tcmalloc.cc' line='297' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- uint64_t TCMallocStats::transfer_bytes -->
        <var-decl name='transfer_bytes' type-id='type-id-15' visibility='default' filepath='src/tcmalloc.cc' line='298' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- uint64_t TCMallocStats::metadata_bytes -->
        <var-decl name='metadata_bytes' type-id='type-id-15' visibility='default' filepath='src/tcmalloc.cc' line='299' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- tcmalloc::PageHeap::Stats TCMallocStats::pageheap -->
        <var-decl name='pageheap' type-id='type-id-1410' visibility='default' filepath='src/tcmalloc.cc' line='300' column='1'/>
      </data-member>
    </class-decl>
    <!-- typedef intptr_t AtomicWord -->
    <typedef-decl name='AtomicWord' type-id='type-id-77' filepath='./src/base/atomicops.h' line='129' column='1' id='type-id-798'/>
    <!-- typedef long int intptr_t -->
    <typedef-decl name='intptr_t' type-id='type-id-80' filepath='/usr/include/stdint.h' line='120' column='1' id='type-id-77'/>
    <!-- class TCMallocImplementation -->
    <class-decl name='TCMallocImplementation' size-in-bits='128' visibility='default' filepath='src/tcmalloc.cc' line='562' column='1' id='type-id-1411'>
      <!-- class MallocExtension -->
      <base-class access='public' layout-offset-in-bits='0' type-id='type-id-803'/>
      <member-type access='private'>
        <!-- typedef void (void*, const base::MallocRange*) TCMallocImplementation::RangeFunction -->
        <typedef-decl name='RangeFunction' type-id='type-id-870' filepath='./src/gperftools/malloc_extension.h' line='143' column='1' id='type-id-1412'/>
      </member-type>
      <data-member access='private' layout-offset-in-bits='64'>
        <!-- size_t TCMallocImplementation::extra_bytes_released_ -->
        <var-decl name='extra_bytes_released_' type-id='type-id-57' visibility='default' filepath='src/tcmalloc.cc' line='570' column='1'/>
      </data-member>
      <member-function access='private' constructor='yes'>
        <!-- TCMallocImplementation::TCMallocImplementation() -->
        <function-decl name='TCMallocImplementation' filepath='src/tcmalloc.cc' line='573' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='7'>
        <!-- void TCMallocImplementation::GetStats(char*, int) -->
        <function-decl name='GetStats' mangled-name='_ZN22TCMallocImplementation8GetStatsEPci' filepath='src/tcmalloc.cc' line='577' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation8GetStatsEPci'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'char*' -->
          <parameter type-id='type-id-113'/>
          <!-- parameter of type 'int' -->
          <parameter type-id='type-id-1'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='8'>
        <!-- void TCMallocImplementation::GetHeapSample(MallocExtensionWriter*) -->
        <function-decl name='GetHeapSample' mangled-name='_ZN22TCMallocImplementation13GetHeapSampleEPSs' filepath='src/tcmalloc.cc' line='590' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation13GetHeapSampleEPSs'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'MallocExtensionWriter*' -->
          <parameter type-id='type-id-872'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='10'>
        <!-- void TCMallocImplementation::Ranges(void*, TCMallocImplementation::RangeFunction*) -->
        <function-decl name='Ranges' mangled-name='_ZN22TCMallocImplementation6RangesEPvPFvS0_PKN4base11MallocRangeEE' filepath='src/tcmalloc.cc' line='622' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation6RangesEPvPFvS0_PKN4base11MallocRangeEE'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- parameter of type 'TCMallocImplementation::RangeFunction*' -->
          <parameter type-id='type-id-1414'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='11'>
        <!-- bool TCMallocImplementation::GetNumericProperty(const char*, size_t*) -->
        <function-decl name='GetNumericProperty' mangled-name='_ZN22TCMallocImplementation18GetNumericPropertyEPKcPm' filepath='src/tcmalloc.cc' line='626' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation18GetNumericPropertyEPKcPm'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'size_t*' -->
          <parameter type-id='type-id-252'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='12'>
        <!-- bool TCMallocImplementation::SetNumericProperty(const char*, size_t) -->
        <function-decl name='SetNumericProperty' mangled-name='_ZN22TCMallocImplementation18SetNumericPropertyEPKcm' filepath='src/tcmalloc.cc' line='711' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation18SetNumericPropertyEPKcm'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- bool -->
          <return type-id='type-id-55'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='13'>
        <!-- void TCMallocImplementation::MarkThreadIdle() -->
        <function-decl name='MarkThreadIdle' mangled-name='_ZN22TCMallocImplementation14MarkThreadIdleEv' filepath='src/tcmalloc.cc' line='728' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation14MarkThreadIdleEv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='14'>
        <!-- void TCMallocImplementation::MarkThreadBusy() -->
        <function-decl name='MarkThreadBusy' mangled-name='_ZN22TCMallocImplementation14MarkThreadBusyEv' filepath='src/tcmalloc.cc' line='1537' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation14MarkThreadBusyEv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='15'>
        <!-- SysAllocator* TCMallocImplementation::GetSystemAllocator() -->
        <function-decl name='GetSystemAllocator' mangled-name='_ZN22TCMallocImplementation18GetSystemAllocatorEv' filepath='src/tcmalloc.cc' line='734' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation18GetSystemAllocatorEv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- SysAllocator* -->
          <return type-id='type-id-874'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='16'>
        <!-- void TCMallocImplementation::SetSystemAllocator(SysAllocator*) -->
        <function-decl name='SetSystemAllocator' mangled-name='_ZN22TCMallocImplementation18SetSystemAllocatorEP12SysAllocator' filepath='src/tcmalloc.cc' line='739' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation18SetSystemAllocatorEP12SysAllocator'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'SysAllocator*' -->
          <parameter type-id='type-id-874'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='17'>
        <!-- void TCMallocImplementation::ReleaseToSystem(size_t) -->
        <function-decl name='ReleaseToSystem' mangled-name='_ZN22TCMallocImplementation15ReleaseToSystemEm' filepath='src/tcmalloc.cc' line='744' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation15ReleaseToSystemEm'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='19'>
        <!-- void TCMallocImplementation::SetMemoryReleaseRate(double) -->
        <function-decl name='SetMemoryReleaseRate' mangled-name='_ZN22TCMallocImplementation20SetMemoryReleaseRateEd' filepath='src/tcmalloc.cc' line='769' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation20SetMemoryReleaseRateEd'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'double' -->
          <parameter type-id='type-id-2'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='20'>
        <!-- double TCMallocImplementation::GetMemoryReleaseRate() -->
        <function-decl name='GetMemoryReleaseRate' mangled-name='_ZN22TCMallocImplementation20GetMemoryReleaseRateEv' filepath='src/tcmalloc.cc' line='773' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation20GetMemoryReleaseRateEv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- double -->
          <return type-id='type-id-2'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='21'>
        <!-- size_t TCMallocImplementation::GetEstimatedAllocatedSize(size_t) -->
        <function-decl name='GetEstimatedAllocatedSize' mangled-name='_ZN22TCMallocImplementation25GetEstimatedAllocatedSizeEm' filepath='src/tcmalloc.cc' line='776' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation25GetEstimatedAllocatedSizeEm'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'typedef size_t' -->
          <parameter type-id='type-id-57'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='22'>
        <!-- size_t TCMallocImplementation::GetAllocatedSize(void*) -->
        <function-decl name='GetAllocatedSize' mangled-name='_ZN22TCMallocImplementation16GetAllocatedSizeEPKv' filepath='src/tcmalloc.cc' line='1529' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation16GetAllocatedSizeEPKv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- typedef size_t -->
          <return type-id='type-id-57'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='23'>
        <!-- MallocExtension::Ownership TCMallocImplementation::GetOwnership(void*) -->
        <function-decl name='GetOwnership' mangled-name='_ZN22TCMallocImplementation12GetOwnershipEPKv' filepath='src/tcmalloc.cc' line='794' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation12GetOwnershipEPKv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'void*' -->
          <parameter type-id='type-id-53'/>
          <!-- enum MallocExtension::Ownership -->
          <return type-id='type-id-867'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='24'>
        <!-- void TCMallocImplementation::GetFreeListSizes(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*) -->
        <function-decl name='GetFreeListSizes' mangled-name='_ZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EE' filepath='src/tcmalloc.cc' line='810' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation16GetFreeListSizesEPSt6vectorIN15MallocExtension12FreeListInfoESaIS2_EE'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
          <parameter type-id='type-id-875'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='25'>
        <!-- void** TCMallocImplementation::ReadStackTraces(int*) -->
        <function-decl name='ReadStackTraces' mangled-name='_ZN22TCMallocImplementation15ReadStackTracesEPi' filepath='src/tcmalloc.cc' line='605' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation15ReadStackTracesEPi'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- parameter of type 'int*' -->
          <parameter type-id='type-id-871'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
      <member-function access='private' vtable-offset='26'>
        <!-- void** TCMallocImplementation::ReadHeapGrowthStackTraces() -->
        <function-decl name='ReadHeapGrowthStackTraces' mangled-name='_ZN22TCMallocImplementation25ReadHeapGrowthStackTracesEv' filepath='src/tcmalloc.cc' line='618' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN22TCMallocImplementation25ReadHeapGrowthStackTracesEv'>
          <!-- implicit parameter of type 'TCMallocImplementation*' -->
          <parameter type-id='type-id-1413' is-artificial='yes'/>
          <!-- void** -->
          <return type-id='type-id-141'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- typedef std::string MallocExtensionWriter -->
    <typedef-decl name='MallocExtensionWriter' type-id='type-id-800' filepath='./src/gperftools/malloc_extension.h' line='68' column='1' id='type-id-928'/>
    <!-- class TCMallocGuard -->
    <class-decl name='TCMallocGuard' size-in-bits='8' visibility='default' filepath='src/tcmalloc_guard.h' line='43' column='1' id='type-id-1415'>
      <member-function access='private' constructor='yes'>
        <!-- TCMallocGuard::TCMallocGuard() -->
        <function-decl name='TCMallocGuard' mangled-name='_ZN13TCMallocGuardC1Ev' filepath='src/tcmalloc_guard.h' line='45' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13TCMallocGuardC1Ev'>
          <!-- implicit parameter of type 'TCMallocGuard*' -->
          <parameter type-id='type-id-1416' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
      <member-function access='private' destructor='yes'>
        <!-- TCMallocGuard::~TCMallocGuard(int) -->
        <function-decl name='~TCMallocGuard' mangled-name='_ZN13TCMallocGuardD1Ev' filepath='src/tcmalloc_guard.h' line='46' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN13TCMallocGuardD1Ev'>
          <!-- implicit parameter of type 'TCMallocGuard*' -->
          <parameter type-id='type-id-1416' is-artificial='yes'/>
          <!-- artificial parameter of type 'int' -->
          <parameter type-id='type-id-1' is-artificial='yes'/>
          <!-- void -->
          <return type-id='type-id-56'/>
        </function-decl>
      </member-function>
    </class-decl>
    <!-- struct mallinfo -->
    <class-decl name='mallinfo' size-in-bits='320' is-struct='yes' visibility='default' filepath='/usr/include/malloc.h' line='94' column='1' id='type-id-1417'>
      <data-member access='public' layout-offset-in-bits='0'>
        <!-- int mallinfo::arena -->
        <var-decl name='arena' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='95' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='32'>
        <!-- int mallinfo::ordblks -->
        <var-decl name='ordblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='96' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='64'>
        <!-- int mallinfo::smblks -->
        <var-decl name='smblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='97' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='96'>
        <!-- int mallinfo::hblks -->
        <var-decl name='hblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='98' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='128'>
        <!-- int mallinfo::hblkhd -->
        <var-decl name='hblkhd' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='99' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='160'>
        <!-- int mallinfo::usmblks -->
        <var-decl name='usmblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='100' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='192'>
        <!-- int mallinfo::fsmblks -->
        <var-decl name='fsmblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='101' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='224'>
        <!-- int mallinfo::uordblks -->
        <var-decl name='uordblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='102' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='256'>
        <!-- int mallinfo::fordblks -->
        <var-decl name='fordblks' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='103' column='1'/>
      </data-member>
      <data-member access='public' layout-offset-in-bits='288'>
        <!-- int mallinfo::keepcost -->
        <var-decl name='keepcost' type-id='type-id-1' visibility='default' filepath='/usr/include/malloc.h' line='104' column='1'/>
      </data-member>
    </class-decl>
    <!-- Atomic32* -->
    <pointer-type-def type-id='type-id-95' size-in-bits='64' id='type-id-94'/>
    <!-- MallocExtension::FreeListInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-868' size-in-bits='64' id='type-id-968'/>
    <!-- MallocExtension::FreeListInfo* -->
    <pointer-type-def type-id='type-id-868' size-in-bits='64' id='type-id-969'/>
    <!-- MallocExtension::FreeListInfo* const -->
    <qualified-type-def type-id='type-id-969' const='yes' id='type-id-987'/>
    <!-- MallocExtension::FreeListInfo* const& -->
    <reference-type-def kind='lvalue' type-id='type-id-987' size-in-bits='64' id='type-id-974'/>
    <!-- MallocExtensionWriter* -->
    <pointer-type-def type-id='type-id-928' size-in-bits='64' id='type-id-872'/>
    <!-- PackedCache<35, long unsigned int>* -->
    <pointer-type-def type-id='type-id-1381' size-in-bits='64' id='type-id-1382'/>
    <!-- SpinLock* -->
    <pointer-type-def type-id='type-id-82' size-in-bits='64' id='type-id-89'/>
    <!-- SpinLockHolder* -->
    <pointer-type-def type-id='type-id-1396' size-in-bits='64' id='type-id-1397'/>
    <!-- SysAllocator* -->
    <pointer-type-def type-id='type-id-929' size-in-bits='64' id='type-id-874'/>
    <!-- TCMallocGuard* -->
    <pointer-type-def type-id='type-id-1415' size-in-bits='64' id='type-id-1416'/>
    <!-- TCMallocImplementation* -->
    <pointer-type-def type-id='type-id-1411' size-in-bits='64' id='type-id-1413'/>
    <!-- TCMallocImplementation::RangeFunction* -->
    <pointer-type-def type-id='type-id-1412' size-in-bits='64' id='type-id-1414'/>
    <!-- TCMalloc_PageMap3<35>* -->
    <pointer-type-def type-id='type-id-1368' size-in-bits='64' id='type-id-1372'/>
    <!-- TCMalloc_PageMap3<35>::Node* -->
    <pointer-type-def type-id='type-id-1369' size-in-bits='64' id='type-id-1371'/>
    <!-- TCMalloc_Printer* -->
    <pointer-type-def type-id='type-id-1378' size-in-bits='64' id='type-id-1379'/>
    <!-- _IO_FILE* -->
    <pointer-type-def type-id='type-id-1384' size-in-bits='64' id='type-id-1387'/>
    <!-- _IO_lock_t* -->
    <pointer-type-def type-id='type-id-1390' size-in-bits='64' id='type-id-1388'/>
    <!-- _IO_marker* -->
    <pointer-type-def type-id='type-id-1389' size-in-bits='64' id='type-id-1386'/>
    <!-- __FILE* -->
    <pointer-type-def type-id='type-id-1385' size-in-bits='64' id='type-id-1418'/>
    <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-963' size-in-bits='64' id='type-id-976'/>
    <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >* -->
    <pointer-type-def type-id='type-id-963' size-in-bits='64' id='type-id-973'/>
    <!-- __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-988' size-in-bits='64' id='type-id-992'/>
    <!-- __gnu_cxx::new_allocator<char>* -->
    <pointer-type-def type-id='type-id-902' size-in-bits='64' id='type-id-934'/>
    <!-- base::MallocRange* -->
    <pointer-type-def type-id='type-id-1419' size-in-bits='64' id='type-id-1420'/>
    <!-- base::internal::HookList<void (*)(const void*)>* -->
    <pointer-type-def type-id='type-id-1076' size-in-bits='64' id='type-id-1081'/>
    <!-- base::internal::HookList<void (*)(const void*, size_t)>* -->
    <pointer-type-def type-id='type-id-1075' size-in-bits='64' id='type-id-1084'/>
    <!-- char& -->
    <reference-type-def kind='lvalue' type-id='type-id-60' size-in-bits='64' id='type-id-302'/>
    <!-- char* -->
    <pointer-type-def type-id='type-id-60' size-in-bits='64' id='type-id-113'/>
    <!-- char** -->
    <pointer-type-def type-id='type-id-113' size-in-bits='64' id='type-id-119'/>
    <!-- const MallocExtension::FreeListInfo -->
    <qualified-type-def type-id='type-id-868' const='yes' id='type-id-977'/>
    <!-- const MallocExtension::FreeListInfo& -->
    <reference-type-def kind='lvalue' type-id='type-id-977' size-in-bits='64' id='type-id-960'/>
    <!-- const MallocExtension::FreeListInfo* -->
    <pointer-type-def type-id='type-id-977' size-in-bits='64' id='type-id-970'/>
    <!-- const PackedCache<35, long unsigned int> -->
    <qualified-type-def type-id='type-id-1381' const='yes' id='type-id-1421'/>
    <!-- const PackedCache<35, long unsigned int>* -->
    <pointer-type-def type-id='type-id-1421' size-in-bits='64' id='type-id-1383'/>
    <!-- const SpinLock -->
    <qualified-type-def type-id='type-id-82' const='yes' id='type-id-97'/>
    <!-- const SpinLock& -->
    <reference-type-def kind='lvalue' type-id='type-id-97' size-in-bits='64' id='type-id-96'/>
    <!-- const SpinLock* -->
    <pointer-type-def type-id='type-id-97' size-in-bits='64' id='type-id-91'/>
    <!-- const TCMalloc_PageMap3<35> -->
    <qualified-type-def type-id='type-id-1368' const='yes' id='type-id-1422'/>
    <!-- const TCMalloc_PageMap3<35>* -->
    <pointer-type-def type-id='type-id-1422' size-in-bits='64' id='type-id-1373'/>
    <!-- const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
    <qualified-type-def type-id='type-id-963' const='yes' id='type-id-990'/>
    <!-- const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
    <reference-type-def kind='lvalue' type-id='type-id-990' size-in-bits='64' id='type-id-1423'/>
    <!-- const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >* -->
    <pointer-type-def type-id='type-id-990' size-in-bits='64' id='type-id-975'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
    <qualified-type-def type-id='type-id-988' const='yes' id='type-id-995'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-995' size-in-bits='64' id='type-id-993'/>
    <!-- const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-995' size-in-bits='64' id='type-id-994'/>
    <!-- const __gnu_cxx::new_allocator<char> -->
    <qualified-type-def type-id='type-id-902' const='yes' id='type-id-971'/>
    <!-- const __gnu_cxx::new_allocator<char>& -->
    <reference-type-def kind='lvalue' type-id='type-id-971' size-in-bits='64' id='type-id-935'/>
    <!-- const __gnu_cxx::new_allocator<char>* -->
    <pointer-type-def type-id='type-id-971' size-in-bits='64' id='type-id-936'/>
    <!-- const base::LinkerInitialized -->
    <qualified-type-def type-id='type-id-90' const='yes' id='type-id-87'/>
    <!-- const base::MallocRange -->
    <qualified-type-def type-id='type-id-1419' const='yes' id='type-id-1424'/>
    <!-- const base::MallocRange* -->
    <pointer-type-def type-id='type-id-1424' size-in-bits='64' id='type-id-1425'/>
    <!-- const base::internal::HookList<void (*)(const void*)> -->
    <qualified-type-def type-id='type-id-1076' const='yes' id='type-id-1087'/>
    <!-- const base::internal::HookList<void (*)(const void*)>* -->
    <pointer-type-def type-id='type-id-1087' size-in-bits='64' id='type-id-1082'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t)> -->
    <qualified-type-def type-id='type-id-1075' const='yes' id='type-id-1088'/>
    <!-- const base::internal::HookList<void (*)(const void*, size_t)>* -->
    <pointer-type-def type-id='type-id-1088' size-in-bits='64' id='type-id-1085'/>
    <!-- const bool -->
    <qualified-type-def type-id='type-id-55' const='yes' id='type-id-477'/>
    <!-- const char -->
    <qualified-type-def type-id='type-id-60' const='yes' id='type-id-58'/>
    <!-- const char& -->
    <reference-type-def kind='lvalue' type-id='type-id-58' size-in-bits='64' id='type-id-303'/>
    <!-- const char* -->
    <pointer-type-def type-id='type-id-58' size-in-bits='64' id='type-id-52'/>
    <!-- const char** -->
    <pointer-type-def type-id='type-id-52' size-in-bits='64' id='type-id-1426'/>
    <!-- const double -->
    <qualified-type-def type-id='type-id-2' const='yes' id='type-id-1230'/>
    <!-- const double& -->
    <reference-type-def kind='lvalue' type-id='type-id-1230' size-in-bits='64' id='type-id-1229'/>
    <!-- const int -->
    <qualified-type-def type-id='type-id-1' const='yes' id='type-id-134'/>
    <!-- const mbstate_t -->
    <qualified-type-def type-id='type-id-1392' const='yes' id='type-id-1427'/>
    <!-- const mbstate_t* -->
    <pointer-type-def type-id='type-id-1427' size-in-bits='64' id='type-id-1428'/>
    <!-- const ptrdiff_t -->
    <qualified-type-def type-id='type-id-208' const='yes' id='type-id-838'/>
    <!-- const ptrdiff_t& -->
    <reference-type-def kind='lvalue' type-id='type-id-838' size-in-bits='64' id='type-id-797'/>
    <!-- const size_t -->
    <qualified-type-def type-id='type-id-57' const='yes' id='type-id-112'/>
    <!-- const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
    <qualified-type-def type-id='type-id-958' const='yes' id='type-id-991'/>
    <!-- const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-991' size-in-bits='64' id='type-id-986'/>
    <!-- const std::allocator<MallocExtension::FreeListInfo> -->
    <qualified-type-def type-id='type-id-982' const='yes' id='type-id-979'/>
    <!-- const std::allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-979' size-in-bits='64' id='type-id-959'/>
    <!-- const std::allocator<char> -->
    <qualified-type-def type-id='type-id-845' const='yes' id='type-id-907'/>
    <!-- const std::allocator<char>& -->
    <reference-type-def kind='lvalue' type-id='type-id-907' size-in-bits='64' id='type-id-843'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
    <qualified-type-def type-id='type-id-796' const='yes' id='type-id-839'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-839' size-in-bits='64' id='type-id-795'/>
    <!-- const std::basic_string<char, std::char_traits<char>, std::allocator<char> >* -->
    <pointer-type-def type-id='type-id-839' size-in-bits='64' id='type-id-847'/>
    <!-- const std::float_denorm_style -->
    <qualified-type-def type-id='type-id-1429' const='yes' id='type-id-1430'/>
    <!-- const std::float_round_style -->
    <qualified-type-def type-id='type-id-1431' const='yes' id='type-id-1432'/>
    <!-- const std::nothrow_t -->
    <qualified-type-def type-id='type-id-1433' const='yes' id='type-id-1434'/>
    <!-- const std::nothrow_t& -->
    <qualified-type-def type-id='type-id-1435' id='type-id-1436'/>
    <!-- const std::nothrow_t& -->
    <reference-type-def kind='lvalue' type-id='type-id-1434' size-in-bits='64' id='type-id-1435'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
    <qualified-type-def type-id='type-id-951' const='yes' id='type-id-980'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-980' size-in-bits='64' id='type-id-961'/>
    <!-- const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-980' size-in-bits='64' id='type-id-964'/>
    <!-- const tcmalloc::PageHeap -->
    <qualified-type-def type-id='type-id-1437' const='yes' id='type-id-1438'/>
    <!-- const tcmalloc::PageHeap* -->
    <pointer-type-def type-id='type-id-1438' size-in-bits='64' id='type-id-1439'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::Span> -->
    <qualified-type-def type-id='type-id-1440' const='yes' id='type-id-1441'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::Span>* -->
    <pointer-type-def type-id='type-id-1441' size-in-bits='64' id='type-id-1442'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::StackTrace> -->
    <qualified-type-def type-id='type-id-1443' const='yes' id='type-id-1444'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>* -->
    <pointer-type-def type-id='type-id-1444' size-in-bits='64' id='type-id-1445'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache> -->
    <qualified-type-def type-id='type-id-1446' const='yes' id='type-id-1447'/>
    <!-- const tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>* -->
    <pointer-type-def type-id='type-id-1447' size-in-bits='64' id='type-id-1448'/>
    <!-- const tcmalloc::ThreadCache -->
    <qualified-type-def type-id='type-id-1449' const='yes' id='type-id-1450'/>
    <!-- const tcmalloc::ThreadCache* -->
    <pointer-type-def type-id='type-id-1450' size-in-bits='64' id='type-id-1451'/>
    <!-- const tcmalloc::ThreadCache::FreeList -->
    <qualified-type-def type-id='type-id-1357' const='yes' id='type-id-1452'/>
    <!-- const tcmalloc::ThreadCache::FreeList* -->
    <pointer-type-def type-id='type-id-1452' size-in-bits='64' id='type-id-1453'/>
    <!-- const tm -->
    <qualified-type-def type-id='type-id-1394' const='yes' id='type-id-1454'/>
    <!-- const tm* -->
    <pointer-type-def type-id='type-id-1454' size-in-bits='64' id='type-id-1455'/>
    <!-- const uintptr_t -->
    <qualified-type-def type-id='type-id-145' const='yes' id='type-id-282'/>
    <!-- const unsigned long int -->
    <qualified-type-def type-id='type-id-5' const='yes' id='type-id-633'/>
    <!-- const unsigned long int& -->
    <reference-type-def kind='lvalue' type-id='type-id-633' size-in-bits='64' id='type-id-352'/>
    <!-- const volatile base::subtle::Atomic64 -->
    <qualified-type-def type-id='type-id-1073' const='yes' id='type-id-1080'/>
    <!-- const volatile base::subtle::Atomic64* -->
    <pointer-type-def type-id='type-id-1080' size-in-bits='64' id='type-id-1078'/>
    <!-- const wchar_t -->
    <qualified-type-def type-id='type-id-1366' const='yes' id='type-id-1456'/>
    <!-- const wchar_t* -->
    <pointer-type-def type-id='type-id-1456' size-in-bits='64' id='type-id-1457'/>
    <!-- const wchar_t** -->
    <pointer-type-def type-id='type-id-1457' size-in-bits='64' id='type-id-1458'/>
    <!-- int (void*, void*)* -->
    <pointer-type-def type-id='type-id-1459' size-in-bits='64' id='type-id-1374'/>
    <!-- int* -->
    <pointer-type-def type-id='type-id-1' size-in-bits='64' id='type-id-871'/>
    <!-- lconv* -->
    <pointer-type-def type-id='type-id-1395' size-in-bits='64' id='type-id-1460'/>
    <!-- mbstate_t* -->
    <pointer-type-def type-id='type-id-1392' size-in-bits='64' id='type-id-1461'/>
    <!-- size_t* -->
    <pointer-type-def type-id='type-id-57' size-in-bits='64' id='type-id-252'/>
    <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-958' size-in-bits='64' id='type-id-984'/>
    <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl* -->
    <pointer-type-def type-id='type-id-981' size-in-bits='64' id='type-id-983'/>
    <!-- std::allocator<MallocExtension::FreeListInfo>& -->
    <reference-type-def kind='lvalue' type-id='type-id-982' size-in-bits='64' id='type-id-985'/>
    <!-- std::allocator<MallocExtension::FreeListInfo>* -->
    <pointer-type-def type-id='type-id-982' size-in-bits='64' id='type-id-989'/>
    <!-- std::allocator<char>* -->
    <pointer-type-def type-id='type-id-845' size-in-bits='64' id='type-id-903'/>
    <!-- std::bad_alloc* -->
    <pointer-type-def type-id='type-id-1462' size-in-bits='64' id='type-id-1463'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-796' size-in-bits='64' id='type-id-851'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >* -->
    <pointer-type-def type-id='type-id-796' size-in-bits='64' id='type-id-848'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider* -->
    <pointer-type-def type-id='type-id-844' size-in-bits='64' id='type-id-846'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
    <reference-type-def kind='lvalue' type-id='type-id-580' size-in-bits='64' id='type-id-841'/>
    <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
    <pointer-type-def type-id='type-id-580' size-in-bits='64' id='type-id-842'/>
    <!-- std::exception* -->
    <pointer-type-def type-id='type-id-1464' size-in-bits='64' id='type-id-1465'/>
    <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
    <reference-type-def kind='lvalue' type-id='type-id-951' size-in-bits='64' id='type-id-962'/>
    <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >* -->
    <pointer-type-def type-id='type-id-951' size-in-bits='64' id='type-id-875'/>
    <!-- tcmalloc::CentralFreeList* -->
    <pointer-type-def type-id='type-id-1466' size-in-bits='64' id='type-id-1467'/>
    <!-- tcmalloc::CentralFreeListPadded* -->
    <pointer-type-def type-id='type-id-1353' size-in-bits='64' id='type-id-1468'/>
    <!-- tcmalloc::LogItem* -->
    <pointer-type-def type-id='type-id-1019' size-in-bits='64' id='type-id-1028'/>
    <!-- tcmalloc::PageHeap* -->
    <pointer-type-def type-id='type-id-1437' size-in-bits='64' id='type-id-1469'/>
    <!-- tcmalloc::PageHeap::LargeSpanStats* -->
    <pointer-type-def type-id='type-id-1470' size-in-bits='64' id='type-id-1471'/>
    <!-- tcmalloc::PageHeap::SmallSpanStats* -->
    <pointer-type-def type-id='type-id-1472' size-in-bits='64' id='type-id-1473'/>
    <!-- tcmalloc::PageHeap::SpanList* -->
    <pointer-type-def type-id='type-id-1355' size-in-bits='64' id='type-id-1474'/>
    <!-- tcmalloc::PageHeap::Stats* -->
    <pointer-type-def type-id='type-id-1410' size-in-bits='64' id='type-id-1475'/>
    <!-- tcmalloc::PageHeapAllocator<tcmalloc::Span>* -->
    <pointer-type-def type-id='type-id-1440' size-in-bits='64' id='type-id-1476'/>
    <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>* -->
    <pointer-type-def type-id='type-id-1443' size-in-bits='64' id='type-id-1477'/>
    <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>* -->
    <pointer-type-def type-id='type-id-1231' size-in-bits='64' id='type-id-1246'/>
    <!-- tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>* -->
    <pointer-type-def type-id='type-id-1446' size-in-bits='64' id='type-id-1478'/>
    <!-- tcmalloc::Sampler* -->
    <pointer-type-def type-id='type-id-1479' size-in-bits='64' id='type-id-1480'/>
    <!-- tcmalloc::SizeMap* -->
    <pointer-type-def type-id='type-id-1481' size-in-bits='64' id='type-id-1482'/>
    <!-- tcmalloc::Span* -->
    <pointer-type-def type-id='type-id-138' size-in-bits='64' id='type-id-144'/>
    <!-- tcmalloc::StackTrace* -->
    <pointer-type-def type-id='type-id-1234' size-in-bits='64' id='type-id-1483'/>
    <!-- tcmalloc::ThreadCache* -->
    <pointer-type-def type-id='type-id-1449' size-in-bits='64' id='type-id-1484'/>
    <!-- tcmalloc::ThreadCache::FreeList* -->
    <pointer-type-def type-id='type-id-1357' size-in-bits='64' id='type-id-1485'/>
    <!-- typedef __va_list_tag __va_list_tag* -->
    <pointer-type-def type-id='type-id-68' size-in-bits='64' id='type-id-67'/>
    <!-- uint64_t* -->
    <pointer-type-def type-id='type-id-15' size-in-bits='64' id='type-id-1486'/>
    <!-- void ()* -->
    <pointer-type-def type-id='type-id-855' size-in-bits='64' id='type-id-176'/>
    <!-- void (void*)* -->
    <pointer-type-def type-id='type-id-858' size-in-bits='64' id='type-id-240'/>
    <!-- void (void*)** -->
    <pointer-type-def type-id='type-id-240' size-in-bits='64' id='type-id-1083'/>
    <!-- void (void*, typedef size_t)* -->
    <pointer-type-def type-id='type-id-864' size-in-bits='64' id='type-id-381'/>
    <!-- void (void*, typedef size_t)** -->
    <pointer-type-def type-id='type-id-381' size-in-bits='64' id='type-id-1086'/>
    <!-- void (void*, void*)* -->
    <pointer-type-def type-id='type-id-1487' size-in-bits='64' id='type-id-1488'/>
    <!-- void* -->
    <pointer-type-def type-id='type-id-56' size-in-bits='64' id='type-id-53'/>
    <!-- void* (typedef size_t, typedef size_t, void*)* -->
    <pointer-type-def type-id='type-id-1489' size-in-bits='64' id='type-id-1490'/>
    <!-- void* (typedef size_t, void*)* -->
    <pointer-type-def type-id='type-id-1491' size-in-bits='64' id='type-id-1492'/>
    <!-- void* (unsigned long int)* -->
    <pointer-type-def type-id='type-id-865' size-in-bits='64' id='type-id-286'/>
    <!-- void* (void*, typedef size_t, void*)* -->
    <pointer-type-def type-id='type-id-1493' size-in-bits='64' id='type-id-1494'/>
    <!-- void** -->
    <pointer-type-def type-id='type-id-53' size-in-bits='64' id='type-id-141'/>
    <!-- volatile Atomic32 -->
    <qualified-type-def type-id='type-id-95' volatile='yes' id='type-id-88'/>
    <!-- volatile Atomic32* -->
    <pointer-type-def type-id='type-id-88' size-in-bits='64' id='type-id-103'/>
    <!-- volatile base::subtle::Atomic64 -->
    <qualified-type-def type-id='type-id-1077' volatile='yes' id='type-id-1073'/>
    <!-- volatile size_t -->
    <qualified-type-def type-id='type-id-57' volatile='yes' id='type-id-1495'/>
    <!-- volatile unsigned long int -->
    <qualified-type-def type-id='type-id-5' volatile='yes' id='type-id-1364'/>
    <!-- wchar_t* -->
    <pointer-type-def type-id='type-id-1366' size-in-bits='64' id='type-id-1496'/>
    <!-- wchar_t** -->
    <pointer-type-def type-id='type-id-1496' size-in-bits='64' id='type-id-1497'/>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- class std::allocator<MallocExtension::FreeListInfo> -->
      <class-decl name='allocator&lt;MallocExtension::FreeListInfo&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='87' column='1' id='type-id-982'>
        <!-- class __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-988'/>
        <member-function access='private'>
          <!-- void std::allocator<MallocExtension::FreeListInfo>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<MallocExtension::FreeListInfo>::allocator(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<MallocExtension::FreeListInfo>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-989' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Destroy_aux<true> -->
      <class-decl name='_Destroy_aux&lt;true&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='106' column='1' id='type-id-1498'>
        <member-function access='public' static='yes'>
          <!-- void std::_Destroy_aux<true>::__destroy<MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*) -->
          <function-decl name='__destroy&lt;MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void std::_Destroy_aux<true>::__destroy<void (**)()>(void ()**) -->
          <function-decl name='__destroy&lt;void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
      <class-decl name='_Vector_base&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt;' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='70' column='1' id='type-id-958'>
        <member-type access='public'>
          <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl -->
          <class-decl name='_Vector_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='75' column='1' id='type-id-981'>
            <!-- class std::allocator<MallocExtension::FreeListInfo> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-982'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_start -->
              <var-decl name='_M_start' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='76' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_finish -->
              <var-decl name='_M_finish' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='77' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_M_end_of_storage -->
              <var-decl name='_M_end_of_storage' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='78' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_Vector_impl() -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl*' -->
                <parameter type-id='type-id-983' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public' constructor='yes'>
              <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl::_Vector_impl(const std::allocator<MallocExtension::FreeListInfo>&) -->
              <function-decl name='_Vector_impl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl*' -->
                <parameter type-id='type-id-983' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
                <parameter type-id='type-id-959'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_impl std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_impl -->
          <var-decl name='_M_impl' type-id='type-id-981' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='136' column='1'/>
        </data-member>
        <member-function access='public'>
          <!-- std::allocator<MallocExtension::FreeListInfo>& std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- std::allocator<MallocExtension::FreeListInfo>& -->
            <return type-id='type-id-985'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const std::allocator<MallocExtension::FreeListInfo>& std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_get_Tp_allocator() -->
          <function-decl name='_M_get_Tp_allocator' mangled-name='_ZNKSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE19_M_get_Tp_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-986' is-artificial='yes'/>
            <!-- const std::allocator<MallocExtension::FreeListInfo>& -->
            <return type-id='type-id-959'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::allocator<MallocExtension::FreeListInfo> std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-986' is-artificial='yes'/>
            <!-- class std::allocator<MallocExtension::FreeListInfo> -->
            <return type-id='type-id-982'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base() -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_Vector_base(unsigned long int, const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::~_Vector_base(int) -->
          <function-decl name='~_Vector_base' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- MallocExtension::FreeListInfo* std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_allocate(unsigned long int) -->
          <function-decl name='_M_allocate' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE11_M_allocateEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_deallocate(MallocExtension::FreeListInfo*, unsigned long int) -->
          <function-decl name='_M_deallocate' mangled-name='_ZNSt12_Vector_baseIN15MallocExtension12FreeListInfoESaIS1_EE13_M_deallocateEPS1_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-984' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
      <class-decl name='vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt;' size-in-bits='192' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='171' column='1' id='type-id-951'>
        <!-- struct std::_Vector_base<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > -->
        <base-class access='protected' layout-offset-in-bits='0' type-id='type-id-958'/>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector() -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(unsigned long int, const MallocExtension::FreeListInfo&, const std::allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- parameter of type 'const std::allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-959'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::vector(const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-961'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::~vector(int) -->
          <function-decl name='~vector' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='312' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator=(const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEaSERKS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-961'/>
            <!-- std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >& -->
            <return type-id='type-id-962'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::assign(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='assign' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='425' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='434' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-965'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::end() -->
          <function-decl name='end' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='443' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='452' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-965'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='461' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-966'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-967'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='479' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-966'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
            <return type-id='type-id-967'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='537' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::resize(unsigned long int, MallocExtension::FreeListInfo) -->
          <function-decl name='resize' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6resizeEmS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='552' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'struct MallocExtension::FreeListInfo' -->
            <parameter type-id='type-id-868'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='574' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EEixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='625' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_range_check(unsigned long int) -->
          <function-decl name='_M_range_check' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_range_checkEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='650' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::front() -->
          <function-decl name='front' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='679' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::front() -->
          <function-decl name='front' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5frontEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::back() -->
          <function-decl name='back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo& std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::back() -->
          <function-decl name='back' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='703' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo& -->
            <return type-id='type-id-960'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::data() -->
          <function-decl name='data' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='714' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo* std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- const MallocExtension::FreeListInfo* -->
            <return type-id='type-id-970'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::push_back(const MallocExtension::FreeListInfo&) -->
          <function-decl name='push_back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE9push_backERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='733' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::pop_back() -->
          <function-decl name='pop_back' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE8pop_backEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, const MallocExtension::FreeListInfo&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::erase(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::erase(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >) -->
          <function-decl name='erase' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EES7_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::swap(std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&) -->
          <function-decl name='swap' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE4swapERS3_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >&' -->
            <parameter type-id='type-id-962'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='950' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_initialize(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_initialize' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE18_M_fill_initializeEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1033' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_assign(unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_assign' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_fill_assignEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_fill_insert(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, unsigned long int, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_fill_insert' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPS1_S3_EEmRKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_insert_aux(__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >, const MallocExtension::FreeListInfo&) -->
          <function-decl name='_M_insert_aux' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/vector.tcc' line='295' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >' -->
            <parameter type-id='type-id-963'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- size_t std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_check_len(unsigned long int, const char*) -->
          <function-decl name='_M_check_len' mangled-name='_ZNKSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE12_M_check_lenEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-964' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='protected'>
          <!-- void std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >::_M_erase_at_end(MallocExtension::FreeListInfo*) -->
          <function-decl name='_M_erase_at_end' mangled-name='_ZNSt6vectorIN15MallocExtension12FreeListInfoESaIS1_EE15_M_erase_at_endEPS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_vector.h' line='1148' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> >*' -->
            <parameter type-id='type-id-875' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::allocator<char> -->
      <class-decl name='allocator&lt;char&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='45' column='1' id='type-id-845'>
        <!-- class __gnu_cxx::new_allocator<char> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-902'/>
        <member-function access='private'>
          <!-- void std::allocator<char>::allocator() -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::allocator<char>::allocator(const std::allocator<char>&) -->
          <function-decl name='allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- std::allocator<char>::~allocator(int) -->
          <function-decl name='~allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/allocator.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::allocator<char>*' -->
            <parameter type-id='type-id-903' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
      <class-decl name='basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='52' column='1' id='type-id-796'>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep -->
          <class-decl name='_Rep' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='148' column='1' id='type-id-580'>
            <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-840'/>
            <data-member access='public' static='yes'>
              <!-- static const size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_max_size -->
              <var-decl name='_S_max_size' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='51' column='1'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static const char std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_terminal -->
              <var-decl name='_S_terminal' type-id='type-id-58' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='56' column='1'/>
            </data-member>
            <data-member access='public' static='yes'>
              <!-- static size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_empty_rep_storage[4] -->
              <var-decl name='_S_empty_rep_storage' type-id='type-id-150' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='68' column='1'/>
            </data-member>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_empty_rep() -->
              <function-decl name='_S_empty_rep' mangled-name='_ZNSs4_Rep12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
                <return type-id='type-id-841'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_is_leaked() -->
              <function-decl name='_M_is_leaked' mangled-name='_ZNKSs4_Rep12_M_is_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-582' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_is_shared() -->
              <function-decl name='_M_is_shared' mangled-name='_ZNKSs4_Rep12_M_is_sharedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='187' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-582' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_leaked() -->
              <function-decl name='_M_set_leaked' mangled-name='_ZNSs4_Rep13_M_set_leakedEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='191' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_sharable() -->
              <function-decl name='_M_set_sharable' mangled-name='_ZNSs4_Rep15_M_set_sharableEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_set_length_and_sharable(unsigned long int) -->
              <function-decl name='_M_set_length_and_sharable' mangled-name='_ZNSs4_Rep26_M_set_length_and_sharableEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_refdata() -->
              <function-decl name='_M_refdata' mangled-name='_ZNSs4_Rep10_M_refdataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_grab(const std::allocator<char>&, const std::allocator<char>&) -->
              <function-decl name='_M_grab' mangled-name='_ZNSs4_Rep7_M_grabERKSaIcES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='218' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public' static='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_create(unsigned long int, const std::allocator<char>&) -->
              <function-decl name='_S_create' mangled-name='_ZNSs4_Rep9_S_createEmmRKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='546' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
                <return type-id='type-id-842'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_dispose(const std::allocator<char>&) -->
              <function-decl name='_M_dispose' mangled-name='_ZNSs4_Rep10_M_disposeERKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_destroy(const std::allocator<char>&) -->
              <function-decl name='_M_destroy' mangled-name='_ZNSs4_Rep10_M_destroyERKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='445' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_refcopy() -->
              <function-decl name='_M_refcopy' mangled-name='_ZNSs4_Rep10_M_refcopyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
            <member-function access='public'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_M_clone(const std::allocator<char>&, unsigned long int) -->
              <function-decl name='_M_clone' mangled-name='_ZNSs4_Rep8_M_cloneERKSaIcEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='624' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep*' -->
                <parameter type-id='type-id-842' is-artificial='yes'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- parameter of type 'unsigned long int' -->
                <parameter type-id='type-id-5'/>
                <!-- char* -->
                <return type-id='type-id-113'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider -->
          <class-decl name='_Alloc_hider' size-in-bits='64' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='258' column='1' id='type-id-844'>
            <!-- class std::allocator<char> -->
            <base-class access='public' layout-offset-in-bits='0' type-id='type-id-845'/>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider::_M_p -->
              <var-decl name='_M_p' type-id='type-id-113' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='262' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider::_Alloc_hider(char*, const std::allocator<char>&) -->
              <function-decl name='_Alloc_hider' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider*' -->
                <parameter type-id='type-id-846' is-artificial='yes'/>
                <!-- parameter of type 'char*' -->
                <parameter type-id='type-id-113'/>
                <!-- parameter of type 'const std::allocator<char>&' -->
                <parameter type-id='type-id-843'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base -->
          <class-decl name='_Rep_base' size-in-bits='192' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='141' column='1' id='type-id-840'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_length -->
              <var-decl name='_M_length' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='142' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_capacity -->
              <var-decl name='_M_capacity' type-id='type-id-57' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='143' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- _Atomic_word std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep_base::_M_refcount -->
              <var-decl name='_M_refcount' type-id='type-id-370' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='144' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <data-member access='public' static='yes'>
          <!-- static const size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::npos -->
          <var-decl name='npos' type-id='type-id-112' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='270' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_dataplus -->
          <var-decl name='_M_dataplus' type-id='type-id-844' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='274' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_data() -->
          <function-decl name='_M_data' mangled-name='_ZNKSs7_M_dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_data(char*) -->
          <function-decl name='_M_data' mangled-name='_ZNSs7_M_dataEPc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_rep() -->
          <function-decl name='_M_rep' mangled-name='_ZNKSs6_M_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='285' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep* -->
            <return type-id='type-id-842'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_ibegin() -->
          <function-decl name='_M_ibegin' mangled-name='_ZNKSs9_M_ibeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='291' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_iend() -->
          <function-decl name='_M_iend' mangled-name='_ZNKSs7_M_iendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_leak() -->
          <function-decl name='_M_leak' mangled-name='_ZNSs7_M_leakEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_check(unsigned long int, const char*) -->
          <function-decl name='_M_check' mangled-name='_ZNKSs8_M_checkEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_check_length(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='_M_check_length' mangled-name='_ZNKSs15_M_check_lengthEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='314' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_limit(unsigned long int, unsigned long int) -->
          <function-decl name='_M_limit' mangled-name='_ZNKSs8_M_limitEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='322' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_disjunct(const char*) -->
          <function-decl name='_M_disjunct' mangled-name='_ZNKSs11_M_disjunctEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_copy(const char*, unsigned long int) -->
          <function-decl name='_M_copy' mangled-name='_ZNSs7_M_copyEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='339' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_move(const char*, unsigned long int) -->
          <function-decl name='_M_move' mangled-name='_ZNSs7_M_moveEPcPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='348' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_assign(unsigned long int, char) -->
          <function-decl name='_M_assign' mangled-name='_ZNSs9_M_assignEPcmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='357' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIS_SsEES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcN9__gnu_cxx17__normal_iteratorIPKcSsEES4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='380' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(char*, char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcS_S_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_copy_chars(const char*, const char*) -->
          <function-decl name='_S_copy_chars' mangled-name='_ZNSs13_S_copy_charsEPcPKcS1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='388' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_compare(unsigned long int) -->
          <function-decl name='_S_compare' mangled-name='_ZNSs10_S_compareEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='392' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate(unsigned long int, unsigned long int, unsigned long int) -->
          <function-decl name='_M_mutate' mangled-name='_ZNSs9_M_mutateEmmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_leak_hard() -->
          <function-decl name='_M_leak_hard' mangled-name='_ZNSs12_M_leak_hardEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_empty_rep() -->
          <function-decl name='_S_empty_rep' mangled-name='_ZNSs12_S_empty_repEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='411' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep& -->
            <return type-id='type-id-841'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string() -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2144' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='194' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const char*, unsigned long int, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='206' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(const char*, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='213' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(unsigned long int, char, const std::allocator<char>&) -->
          <function-decl name='basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='220' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public' destructor='yes'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string(int) -->
          <function-decl name='~basic_string' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='502' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='510' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(const char*) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator=(char) -->
          <function-decl name='operator=' mangled-name='_ZNSsaSEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNSs5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='554' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::begin() -->
          <function-decl name='begin' mangled-name='_ZNKSs5beginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-850'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::end() -->
          <function-decl name='end' mangled-name='_ZNSs3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='573' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::end() -->
          <function-decl name='end' mangled-name='_ZNKSs3endEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='584' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-850'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNSs6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='593' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-852'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rbegin() -->
          <function-decl name='rbegin' mangled-name='_ZNKSs6rbeginEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='602' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-853'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNSs4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='611' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-852'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rend() -->
          <function-decl name='rend' mangled-name='_ZNKSs4rendEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='620' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
            <return type-id='type-id-853'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::size() -->
          <function-decl name='size' mangled-name='_ZNKSs4sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::length() -->
          <function-decl name='length' mangled-name='_ZNKSs6lengthEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='634' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNKSs8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::resize(unsigned long int, char) -->
          <function-decl name='resize' mangled-name='_ZNSs6resizeEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='640' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::resize(unsigned long int) -->
          <function-decl name='resize' mangled-name='_ZNSs6resizeEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='666' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::capacity() -->
          <function-decl name='capacity' mangled-name='_ZNKSs8capacityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='674' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::reserve(unsigned long int) -->
          <function-decl name='reserve' mangled-name='_ZNSs7reserveEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='502' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::clear() -->
          <function-decl name='clear' mangled-name='_ZNSs5clearEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- bool std::basic_string<char, std::char_traits<char>, std::allocator<char> >::empty() -->
          <function-decl name='empty' mangled-name='_ZNKSs5emptyEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='708' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNKSsixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned long int) -->
          <function-decl name='operator[]' mangled-name='_ZNSsixEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='740' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNKSs2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='761' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- const char& -->
            <return type-id='type-id-303'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- char& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::at(unsigned long int) -->
          <function-decl name='at' mangled-name='_ZNSs2atEm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='780' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- char& -->
            <return type-id='type-id-302'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='795' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(const char*) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='804' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator+=(char) -->
          <function-decl name='operator+=' mangled-name='_ZNSspLEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='813' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='append' mangled-name='_ZNSs6appendERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='325' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSs6appendERKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='342' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const char*, unsigned long int) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='298' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(const char*) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='868' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::append(unsigned long int, char) -->
          <function-decl name='append' mangled-name='_ZNSs6appendEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::push_back(char) -->
          <function-decl name='push_back' mangled-name='_ZNSs9push_backEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='914' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='243' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignERKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='944' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const char*, unsigned long int) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(const char*) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='972' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::assign(unsigned long int, char) -->
          <function-decl name='assign' mangled-name='_ZNSs6assignEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='988' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEN9__gnu_cxx17__normal_iteratorIPcSsEEmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1028' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1071' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1093' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const char*, unsigned long int) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, const char*) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1134' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(unsigned long int, unsigned long int, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1157' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::insert(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, char) -->
          <function-decl name='insert' mangled-name='_ZNSs6insertEN9__gnu_cxx17__normal_iteratorIPcSsEEc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1174' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(unsigned long int, unsigned long int) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1198' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEN9__gnu_cxx17__normal_iteratorIPcSsEE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1214' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::erase(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='erase' mangled-name='_ZNSs5eraseEN9__gnu_cxx17__normal_iteratorIPcSsEES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='391' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
            <return type-id='type-id-849'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1253' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1275' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1318' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1341' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_RKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1359' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*, unsigned long int) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1377' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1398' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, unsigned long int, char) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_mc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1419' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, char*, char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_S1_S1_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1455' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, const char*, const char*) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_PKcS4_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1465' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_S2_S2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1476' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) -->
          <function-decl name='replace' mangled-name='_ZNSs7replaceEN9__gnu_cxx17__normal_iteratorIPcSsEES2_NS0_IPKcSsEES5_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1486' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-849'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- parameter of type 'class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' -->
            <parameter type-id='type-id-850'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_replace_aux(unsigned long int, unsigned long int, unsigned long int, char) -->
          <function-decl name='_M_replace_aux' mangled-name='_ZNSs14_M_replace_auxEmmmc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='668' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_replace_safe(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='_M_replace_safe' mangled-name='_ZNSs15_M_replace_safeEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='681' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> >& -->
            <return type-id='type-id-851'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_S_construct(char, const std::allocator<char>&) -->
          <function-decl name='_S_construct' mangled-name='_ZNSs12_S_constructEmcRKSaIcE' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'const std::allocator<char>&' -->
            <parameter type-id='type-id-843'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::copy(char*, unsigned long int, unsigned long int) -->
          <function-decl name='copy' mangled-name='_ZNKSs4copyEPcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='723' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- void std::basic_string<char, std::char_traits<char>, std::allocator<char> >::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='swap' mangled-name='_ZNSs4swapERSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='519' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-848' is-artificial='yes'/>
            <!-- parameter of type 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-851'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::c_str() -->
          <function-decl name='c_str' mangled-name='_ZNKSs5c_strEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1612' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- const char* std::basic_string<char, std::char_traits<char>, std::allocator<char> >::data() -->
          <function-decl name='data' mangled-name='_ZNKSs4dataEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1622' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::allocator<char> std::basic_string<char, std::char_traits<char>, std::allocator<char> >::get_allocator() -->
          <function-decl name='get_allocator' mangled-name='_ZNKSs13get_allocatorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1629' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- class std::allocator<char> -->
            <return type-id='type-id-845'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='737' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1657' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(const char*, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1671' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find(char, unsigned long int) -->
          <function-decl name='find' mangled-name='_ZNKSs4findEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='760' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1701' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='778' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(const char*, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1729' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::rfind(char, unsigned long int) -->
          <function-decl name='rfind' mangled-name='_ZNKSs5rfindEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='799' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1759' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='816' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(const char*, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1787' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_of(char, unsigned long int) -->
          <function-decl name='find_first_of' mangled-name='_ZNKSs13find_first_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1806' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1820' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='831' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(const char*, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1848' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_of(char, unsigned long int) -->
          <function-decl name='find_last_of' mangled-name='_ZNKSs12find_last_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1867' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1881' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(const char*, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1910' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_first_not_of(char, unsigned long int) -->
          <function-decl name='find_first_not_of' mangled-name='_ZNKSs17find_first_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='864' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofERKSsm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1940' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const char*, unsigned long int, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEPKcmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='875' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(const char*, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='1969' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- size_t std::basic_string<char, std::char_traits<char>, std::allocator<char> >::find_last_not_of(char, unsigned long int) -->
          <function-decl name='find_last_not_of' mangled-name='_ZNKSs16find_last_not_ofEcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='896' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'char' -->
            <parameter type-id='type-id-60'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::basic_string<char, std::char_traits<char>, std::allocator<char> >::substr(unsigned long int, unsigned long int) -->
          <function-decl name='substr' mangled-name='_ZNKSs6substrEmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2001' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- struct std::basic_string<char, std::char_traits<char>, std::allocator<char> > -->
            <return type-id='type-id-796'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareERKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.h' line='2019' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmRKSs' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='916' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long int, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmRKSsmm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='931' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&' -->
            <parameter type-id='type-id-795'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='949' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const char*) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmPKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='964' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='public'>
          <!-- int std::basic_string<char, std::char_traits<char>, std::allocator<char> >::compare(unsigned long int, unsigned long int, const char*, unsigned long int) -->
          <function-decl name='compare' mangled-name='_ZNKSs7compareEmmPKcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/basic_string.tcc' line='980' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*' -->
            <parameter type-id='type-id-847' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__copy_move<false, true, std::random_access_iterator_tag> -->
      <class-decl name='__copy_move&lt;false, true, std::random_access_iterator_tag&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='307' column='1' id='type-id-1499'>
        <member-function access='public' static='yes'>
          <!-- MallocExtension::FreeListInfo* std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<MallocExtension::FreeListInfo>(const MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
          <function-decl name='__copy_m&lt;MallocExtension::FreeListInfo&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-970'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-970'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void ()** std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<void (*)()>(void ()* const*, void ()**) -->
          <function-decl name='__copy_m&lt;void (*)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()* const*' -->
            <parameter type-id='type-id-717'/>
            <!-- parameter of type 'void ()* const*' -->
            <parameter type-id='type-id-717'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void** std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<void*>(void* const*, void**) -->
          <function-decl name='__copy_m&lt;void*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void** std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<const void*>(void* const*, void**) -->
          <function-decl name='__copy_m&lt;const void*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__copy_move_backward<false, true, std::random_access_iterator_tag> -->
      <class-decl name='__copy_move_backward&lt;false, true, std::random_access_iterator_tag&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='511' column='1' id='type-id-1500'>
        <member-function access='public' static='yes'>
          <!-- MallocExtension::FreeListInfo* std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<MallocExtension::FreeListInfo>(const MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
          <function-decl name='__copy_move_b&lt;MallocExtension::FreeListInfo&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-970'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-970'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void ()** std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<void (*)()>(void ()* const*, void ()**) -->
          <function-decl name='__copy_move_b&lt;void (*)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()* const*' -->
            <parameter type-id='type-id-717'/>
            <!-- parameter of type 'void ()* const*' -->
            <parameter type-id='type-id-717'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void** std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<void*>(void* const*, void**) -->
          <function-decl name='__copy_move_b&lt;void*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void* const*' -->
            <parameter type-id='type-id-173'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- void** -->
            <return type-id='type-id-141'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- HeapProfileTable::AllocValue::Bucket** std::__copy_move_backward<false, true, std::random_access_iterator_tag>::__copy_move_b<HeapProfileTable::Bucket*>(HeapProfileTable::AllocValue::Bucket* const*, HeapProfileTable::AllocValue::Bucket**) -->
          <function-decl name='__copy_move_b&lt;HeapProfileTable::Bucket*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='572' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket* const*' -->
            <parameter type-id='type-id-890'/>
            <!-- parameter of type 'HeapProfileTable::AllocValue::Bucket**' -->
            <parameter type-id='type-id-248'/>
            <!-- HeapProfileTable::AllocValue::Bucket** -->
            <return type-id='type-id-248'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__niter_base<MallocExtension::FreeListInfo*, false> -->
      <class-decl name='__niter_base&lt;MallocExtension::FreeListInfo*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='267' column='1' id='type-id-1501'>
        <member-function access='public' static='yes'>
          <!-- MallocExtension::FreeListInfo* std::__niter_base<MallocExtension::FreeListInfo*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__niter_baseIPN15MallocExtension12FreeListInfoELb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='269' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::__miter_base<MallocExtension::FreeListInfo*, false> -->
      <class-decl name='__miter_base&lt;MallocExtension::FreeListInfo*, false&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='285' column='1' id='type-id-1502'>
        <member-function access='public' static='yes'>
          <!-- MallocExtension::FreeListInfo* std::__miter_base<MallocExtension::FreeListInfo*, false>::__b() -->
          <function-decl name='__b' mangled-name='_ZNSt12__miter_baseIPN15MallocExtension12FreeListInfoELb0EE3__bES2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct std::numeric_limits<long unsigned int> -->
      <class-decl name='numeric_limits&lt;long unsigned int&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='926' column='1' id='type-id-1503'>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_specialized -->
          <var-decl name='is_specialized' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='927' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::digits -->
          <var-decl name='digits' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='934' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::digits10 -->
          <var-decl name='digits10' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='935' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_signed -->
          <var-decl name='is_signed' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='936' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_integer -->
          <var-decl name='is_integer' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='937' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_exact -->
          <var-decl name='is_exact' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='938' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::radix -->
          <var-decl name='radix' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='939' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::min_exponent -->
          <var-decl name='min_exponent' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='945' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::min_exponent10 -->
          <var-decl name='min_exponent10' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='946' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::max_exponent -->
          <var-decl name='max_exponent' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='947' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const int std::numeric_limits<long unsigned int>::max_exponent10 -->
          <var-decl name='max_exponent10' type-id='type-id-134' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='948' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::has_infinity -->
          <var-decl name='has_infinity' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='950' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::has_quiet_NaN -->
          <var-decl name='has_quiet_NaN' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='951' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::has_signaling_NaN -->
          <var-decl name='has_signaling_NaN' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='952' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const std::float_denorm_style std::numeric_limits<long unsigned int>::has_denorm -->
          <var-decl name='has_denorm' type-id='type-id-1430' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='953' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::has_denorm_loss -->
          <var-decl name='has_denorm_loss' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='954' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_iec559 -->
          <var-decl name='is_iec559' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='965' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_bounded -->
          <var-decl name='is_bounded' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='966' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::is_modulo -->
          <var-decl name='is_modulo' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='967' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::traps -->
          <var-decl name='traps' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='969' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const bool std::numeric_limits<long unsigned int>::tinyness_before -->
          <var-decl name='tinyness_before' type-id='type-id-477' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='970' column='1'/>
        </data-member>
        <data-member access='public' static='yes'>
          <!-- static const std::float_round_style std::numeric_limits<long unsigned int>::round_style -->
          <var-decl name='round_style' type-id='type-id-1432' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='971' column='1'/>
        </data-member>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::min() -->
          <function-decl name='min' mangled-name='_ZNSt14numeric_limitsImE3minEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='929' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::max() -->
          <function-decl name='max' mangled-name='_ZNSt14numeric_limitsImE3maxEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='931' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::epsilon() -->
          <function-decl name='epsilon' mangled-name='_ZNSt14numeric_limitsImE7epsilonEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='940' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::round_error() -->
          <function-decl name='round_error' mangled-name='_ZNSt14numeric_limitsImE11round_errorEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='942' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::infinity() -->
          <function-decl name='infinity' mangled-name='_ZNSt14numeric_limitsImE8infinityEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='956' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::quiet_NaN() -->
          <function-decl name='quiet_NaN' mangled-name='_ZNSt14numeric_limitsImE9quiet_NaNEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='958' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::signaling_NaN() -->
          <function-decl name='signaling_NaN' mangled-name='_ZNSt14numeric_limitsImE13signaling_NaNEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='960' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- unsigned long int std::numeric_limits<long unsigned int>::denorm_min() -->
          <function-decl name='denorm_min' mangled-name='_ZNSt14numeric_limitsImE10denorm_minEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='962' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- unsigned long int -->
            <return type-id='type-id-5'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- enum std::float_denorm_style -->
      <enum-decl name='float_denorm_style' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='168' column='1' id='type-id-1429'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='denorm_indeterminate' value='-1'/>
        <enumerator name='denorm_absent' value='0'/>
        <enumerator name='denorm_present' value='1'/>
      </enum-decl>
      <!-- enum std::float_round_style -->
      <enum-decl name='float_round_style' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/limits' line='153' column='1' id='type-id-1431'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='round_indeterminate' value='-1'/>
        <enumerator name='round_toward_zero' value='0'/>
        <enumerator name='round_to_nearest' value='1'/>
        <enumerator name='round_toward_infinity' value='2'/>
        <enumerator name='round_toward_neg_infinity' value='3'/>
      </enum-decl>
      <!-- typedef std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::string -->
      <typedef-decl name='string' type-id='type-id-796' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stringfwd.h' line='56' column='1' id='type-id-800'/>
      <!-- struct std::nothrow_t -->
      <class-decl name='nothrow_t' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/new' line='67' column='1' id='type-id-1433'/>
      <!-- struct std::__uninitialized_copy<true> -->
      <class-decl name='__uninitialized_copy&lt;true&gt;' size-in-bits='8' is-struct='yes' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='87' column='1' id='type-id-1504'>
        <member-function access='public' static='yes'>
          <!-- MallocExtension::FreeListInfo* std::__uninitialized_copy<true>::uninitialized_copy<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
          <function-decl name='uninitialized_copy&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='public' static='yes'>
          <!-- void ()** std::__uninitialized_copy<true>::uninitialized_copy<void (**)(), void (**)()>(void ()**, void ()**) -->
          <function-decl name='uninitialized_copy&lt;void (**)(), void (**)()&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- parameter of type 'void ()**' -->
            <parameter type-id='type-id-719'/>
            <!-- void ()** -->
            <return type-id='type-id-719'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- void std::_Destroy<MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='_Destroy&lt;MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void std::_Destroy<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, std::allocator<MallocExtension::FreeListInfo>&) -->
      <function-decl name='_Destroy&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_construct.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'std::allocator<MallocExtension::FreeListInfo>&' -->
        <parameter type-id='type-id-985'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__copy_move_backward_a<false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='__copy_move_backward_a&lt;false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='582' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__copy_move_backward_a2<false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='__copy_move_backward_a2&lt;false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='600' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__copy_move_a<false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='__copy_move_a&lt;false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='386' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__copy_move_a2<false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='__copy_move_a2&lt;false, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='431' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::copy<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='copy&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='458' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::uninitialized_copy<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='uninitialized_copy&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__uninitialized_copy_a<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, std::allocator<MallocExtension::FreeListInfo>&) -->
      <function-decl name='__uninitialized_copy_a&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='254' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'std::allocator<MallocExtension::FreeListInfo>&' -->
        <parameter type-id='type-id-985'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- const unsigned long int& std::max<long unsigned int>(const unsigned long int&, const unsigned long int&) -->
      <function-decl name='max&lt;long unsigned int&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const unsigned long int&' -->
        <parameter type-id='type-id-352'/>
        <!-- parameter of type 'const unsigned long int&' -->
        <parameter type-id='type-id-352'/>
        <!-- const unsigned long int& -->
        <return type-id='type-id-352'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::copy_backward<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*>(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*) -->
      <function-decl name='copy_backward&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- MallocExtension::FreeListInfo* std::__uninitialized_move_a<MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, std::allocator<MallocExtension::FreeListInfo> >(MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, std::allocator<MallocExtension::FreeListInfo>&) -->
      <function-decl name='__uninitialized_move_a&lt;MallocExtension::FreeListInfo*, MallocExtension::FreeListInfo*, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_uninitialized.h' line='261' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
        <parameter type-id='type-id-969'/>
        <!-- parameter of type 'std::allocator<MallocExtension::FreeListInfo>&' -->
        <parameter type-id='type-id-985'/>
        <!-- MallocExtension::FreeListInfo* -->
        <return type-id='type-id-969'/>
      </function-decl>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-966'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-967'/>
      <!-- class std::exception -->
      <class-decl name='exception' visibility='default' is-declaration-only='yes' id='type-id-1464'>
        <member-function access='private' constructor='yes'>
          <!-- std::exception::exception() -->
          <function-decl name='exception' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/exception' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::exception*' -->
            <parameter type-id='type-id-1465' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::bad_alloc -->
      <class-decl name='bad_alloc' visibility='default' is-declaration-only='yes' id='type-id-1462'>
        <member-function access='private' constructor='yes'>
          <!-- std::bad_alloc::bad_alloc() -->
          <function-decl name='bad_alloc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/new' line='57' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'std::bad_alloc*' -->
            <parameter type-id='type-id-1463' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-852'/>
      <!-- class std::reverse_iterator<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > -->
      <class-decl name='reverse_iterator&lt;__gnu_cxx::__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-853'/>
    </namespace-decl>
    <!-- namespace __gnu_cxx -->
    <namespace-decl name='__gnu_cxx'>
      <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
      <class-decl name='__normal_iterator&lt;MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt;' size-in-bits='64' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='669' column='1' id='type-id-963'>
        <data-member access='protected' layout-offset-in-bits='0'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::_M_current -->
          <var-decl name='_M_current' type-id='type-id-969' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='671' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::__normal_iterator() -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='683' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::__normal_iterator(MallocExtension::FreeListInfo* const&) -->
          <function-decl name='__normal_iterator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='686' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo* const&' -->
            <parameter type-id='type-id-974'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator*() -->
          <function-decl name='operator*' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEdeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='698' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;>() -->
          <function-decl name='operator-&gt;' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEptEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='702' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator++() -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEppEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='706' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator++(int) -->
          <function-decl name='operator++' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEppEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='713' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;&#45;() -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmmEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='718' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;&#45;(int) -->
          <function-decl name='operator--' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmmEi' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='725' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator[](const ptrdiff_t&) -->
          <function-decl name='operator[]' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEixERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='730' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- MallocExtension::FreeListInfo& -->
            <return type-id='type-id-968'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator+=(const ptrdiff_t&) -->
          <function-decl name='operator+=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEpLERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='734' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator+(const ptrdiff_t&) -->
          <function-decl name='operator+' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEplERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='738' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;=(const ptrdiff_t&) -->
          <function-decl name='operator-=' mangled-name='_ZN9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmIERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='742' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-973' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >& -->
            <return type-id='type-id-976'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::operator&#45;(const ptrdiff_t&) -->
          <function-decl name='operator-' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEEmiERKl' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='746' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- parameter of type 'const ptrdiff_t&' -->
            <parameter type-id='type-id-797'/>
            <!-- class __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
            <return type-id='type-id-963'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* const& __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >::base() -->
          <function-decl name='base' mangled-name='_ZNK9__gnu_cxx17__normal_iteratorIPN15MallocExtension12FreeListInfoESt6vectorIS2_SaIS2_EEE4baseEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >*' -->
            <parameter type-id='type-id-975' is-artificial='yes'/>
            <!-- MallocExtension::FreeListInfo* const& -->
            <return type-id='type-id-974'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<MallocExtension::FreeListInfo> -->
      <class-decl name='new_allocator&lt;MallocExtension::FreeListInfo&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-988'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::new_allocator(const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>&' -->
            <parameter type-id='type-id-993'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::address(MallocExtension::FreeListInfo&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7addressERS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-968'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::address(const MallocExtension::FreeListInfo&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7addressERKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- const MallocExtension::FreeListInfo* -->
            <return type-id='type-id-970'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- MallocExtension::FreeListInfo* __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- MallocExtension::FreeListInfo* -->
            <return type-id='type-id-969'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::deallocate(MallocExtension::FreeListInfo*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE10deallocateEPS2_m' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-994' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::construct(MallocExtension::FreeListInfo*, const MallocExtension::FreeListInfo&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE9constructEPS2_RKS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- parameter of type 'const MallocExtension::FreeListInfo&' -->
            <parameter type-id='type-id-960'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<MallocExtension::FreeListInfo>::destroy(MallocExtension::FreeListInfo*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIN15MallocExtension12FreeListInfoEE7destroyEPS2_' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<MallocExtension::FreeListInfo>*' -->
            <parameter type-id='type-id-992' is-artificial='yes'/>
            <!-- parameter of type 'MallocExtension::FreeListInfo*' -->
            <parameter type-id='type-id-969'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class __gnu_cxx::new_allocator<char> -->
      <class-decl name='new_allocator&lt;char&gt;' size-in-bits='8' visibility='default' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='52' column='1' id='type-id-902'>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::new_allocator() -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::new_allocator(const __gnu_cxx::new_allocator<char>&) -->
          <function-decl name='new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'const __gnu_cxx::new_allocator<char>&' -->
            <parameter type-id='type-id-935'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' destructor='yes'>
          <!-- __gnu_cxx::new_allocator<char>::~new_allocator(int) -->
          <function-decl name='~new_allocator' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- artificial parameter of type 'int' -->
            <parameter type-id='type-id-1' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* __gnu_cxx::new_allocator<char>::address(char&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE7addressERc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- parameter of type 'char&' -->
            <parameter type-id='type-id-302'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- const char* __gnu_cxx::new_allocator<char>::address(const char&) -->
          <function-decl name='address' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE7addressERKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- parameter of type 'const char&' -->
            <parameter type-id='type-id-303'/>
            <!-- const char* -->
            <return type-id='type-id-52'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- char* __gnu_cxx::new_allocator<char>::allocate(unsigned long int, void*) -->
          <function-decl name='allocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE8allocateEmPKv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- char* -->
            <return type-id='type-id-113'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::deallocate(char*, unsigned long int) -->
          <function-decl name='deallocate' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE10deallocateEPcm' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t __gnu_cxx::new_allocator<char>::max_size() -->
          <function-decl name='max_size' mangled-name='_ZNK9__gnu_cxx13new_allocatorIcE8max_sizeEv' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const __gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-936' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::construct(char*, const char&) -->
          <function-decl name='construct' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE9constructEPcRKc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- parameter of type 'const char&' -->
            <parameter type-id='type-id-303'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void __gnu_cxx::new_allocator<char>::destroy(char*) -->
          <function-decl name='destroy' mangled-name='_ZN9__gnu_cxx13new_allocatorIcE7destroyEPc' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/ext/new_allocator.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type '__gnu_cxx::new_allocator<char>*' -->
            <parameter type-id='type-id-934' is-artificial='yes'/>
            <!-- parameter of type 'char*' -->
            <parameter type-id='type-id-113'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- long long int __gnu_cxx::abs(long long int) -->
      <function-decl name='abs' mangled-name='_ZN9__gnu_cxx3absEx' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/cstdlib' line='170' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'long long int' -->
        <parameter type-id='type-id-1029'/>
        <!-- long long int -->
        <return type-id='type-id-1029'/>
      </function-decl>
      <!-- lldiv_t __gnu_cxx::div(long long int, long long int) -->
      <function-decl name='div' mangled-name='_ZN9__gnu_cxx3divExx' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/cstdlib' line='176' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'long long int' -->
        <parameter type-id='type-id-1029'/>
        <!-- parameter of type 'long long int' -->
        <parameter type-id='type-id-1029'/>
        <!-- struct lldiv_t -->
        <return type-id='type-id-1367'/>
      </function-decl>
      <!-- ptrdiff_t __gnu_cxx::operator&#45;<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >(const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >&, const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >&) -->
      <function-decl name='operator-&lt;MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_iterator.h' line='856' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >&' -->
        <parameter type-id='type-id-1423'/>
        <!-- parameter of type 'const __gnu_cxx::__normal_iterator<MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > >&' -->
        <parameter type-id='type-id-1423'/>
        <!-- typedef ptrdiff_t -->
        <return type-id='type-id-208'/>
      </function-decl>
      <!-- class __gnu_cxx::__normal_iterator<const MallocExtension::FreeListInfo*, std::vector<MallocExtension::FreeListInfo, std::allocator<MallocExtension::FreeListInfo> > > -->
      <class-decl name='__normal_iterator&lt;const MallocExtension::FreeListInfo*, std::vector&lt;MallocExtension::FreeListInfo, std::allocator&lt;MallocExtension::FreeListInfo&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-965'/>
      <!-- class __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
      <class-decl name='__normal_iterator&lt;char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-849'/>
      <!-- class __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > -->
      <class-decl name='__normal_iterator&lt;const char*, std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; &gt;' visibility='default' is-declaration-only='yes' id='type-id-850'/>
    </namespace-decl>
    <!-- int atexit(void ()*) -->
    <function-decl name='atexit' filepath='/usr/include/stdlib.h' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'void ()*' -->
      <parameter type-id='type-id-176'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- double atof(const char*) -->
    <function-decl name='atof' filepath='/usr/include/stdlib.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- double -->
      <return type-id='type-id-2'/>
    </function-decl>
    <!-- int atoi(const char*) -->
    <function-decl name='atoi' filepath='/usr/include/stdlib.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- long int atol(const char*) -->
    <function-decl name='atol' filepath='/usr/include/stdlib.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- long int -->
      <return type-id='type-id-80'/>
    </function-decl>
    <!-- void* bsearch(void*, void*, size_t, size_t, __compar_fn_t) -->
    <function-decl name='bsearch' filepath='/usr/include/stdlib.h' line='755' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef __compar_fn_t' -->
      <parameter type-id='type-id-1375'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* calloc(size_t, size_t) -->
    <function-decl name='calloc' filepath='/usr/include/stdlib.h' line='473' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- div_t div(int, int) -->
    <function-decl name='div' filepath='/usr/include/stdlib.h' line='785' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- struct div_t -->
      <return type-id='type-id-1376'/>
    </function-decl>
    <!-- void free(void*) -->
    <function-decl name='free' filepath='/usr/include/stdlib.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- char* getenv(const char*) -->
    <function-decl name='getenv' filepath='/usr/include/stdlib.h' line='567' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- char* -->
      <return type-id='type-id-113'/>
    </function-decl>
    <!-- ldiv_t ldiv(long int, long int) -->
    <function-decl name='ldiv' filepath='/usr/include/stdlib.h' line='787' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'long int' -->
      <parameter type-id='type-id-80'/>
      <!-- parameter of type 'long int' -->
      <parameter type-id='type-id-80'/>
      <!-- struct ldiv_t -->
      <return type-id='type-id-1377'/>
    </function-decl>
    <!-- void* malloc(size_t) -->
    <function-decl name='malloc' filepath='/usr/include/stdlib.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- int mblen(const char*, size_t) -->
    <function-decl name='mblen' filepath='/usr/include/stdlib.h' line='860' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- size_t mbstowcs(wchar_t*, const char*, size_t) -->
    <function-decl name='mbstowcs' filepath='/usr/include/stdlib.h' line='871' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- int mbtowc(wchar_t*, const char*, size_t) -->
    <function-decl name='mbtowc' filepath='/usr/include/stdlib.h' line='863' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void qsort(void*, size_t, size_t, __compar_fn_t) -->
    <function-decl name='qsort' filepath='/usr/include/stdlib.h' line='761' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef __compar_fn_t' -->
      <parameter type-id='type-id-1375'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- int rand() -->
    <function-decl name='rand' filepath='/usr/include/stdlib.h' line='380' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void* realloc(void*, size_t) -->
    <function-decl name='realloc' filepath='/usr/include/stdlib.h' line='485' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void srand(unsigned int) -->
    <function-decl name='srand' filepath='/usr/include/stdlib.h' line='382' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'unsigned int' -->
      <parameter type-id='type-id-59'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- double strtod(const char*, char**) -->
    <function-decl name='strtod' filepath='/usr/include/stdlib.h' line='165' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- double -->
      <return type-id='type-id-2'/>
    </function-decl>
    <!-- long int strtol(const char*, char**, int) -->
    <function-decl name='strtol' filepath='/usr/include/stdlib.h' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long int -->
      <return type-id='type-id-80'/>
    </function-decl>
    <!-- unsigned long int strtoul(const char*, char**, int) -->
    <function-decl name='strtoul' filepath='/usr/include/stdlib.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- unsigned long int -->
      <return type-id='type-id-5'/>
    </function-decl>
    <!-- int system(const char*) -->
    <function-decl name='system' filepath='/usr/include/stdlib.h' line='717' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- size_t wcstombs(char*, const wchar_t*, size_t) -->
    <function-decl name='wcstombs' filepath='/usr/include/stdlib.h' line='874' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- int wctomb(char*, wchar_t) -->
    <function-decl name='wctomb' filepath='/usr/include/stdlib.h' line='867' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- lldiv_t lldiv(long long int, long long int) -->
    <function-decl name='lldiv' filepath='/usr/include/stdlib.h' line='793' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'long long int' -->
      <parameter type-id='type-id-1029'/>
      <!-- parameter of type 'long long int' -->
      <parameter type-id='type-id-1029'/>
      <!-- struct lldiv_t -->
      <return type-id='type-id-1367'/>
    </function-decl>
    <!-- long long int atoll(const char*) -->
    <function-decl name='atoll' filepath='/usr/include/stdlib.h' line='158' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- long long int -->
      <return type-id='type-id-1029'/>
    </function-decl>
    <!-- long long int strtoll(const char*, char**, int) -->
    <function-decl name='strtoll' filepath='/usr/include/stdlib.h' line='210' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long long int -->
      <return type-id='type-id-1029'/>
    </function-decl>
    <!-- long long unsigned int strtoull(const char*, char**, int) -->
    <function-decl name='strtoull' filepath='/usr/include/stdlib.h' line='215' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long long unsigned int -->
      <return type-id='type-id-1030'/>
    </function-decl>
    <!-- float strtof(const char*, char**) -->
    <function-decl name='strtof' filepath='/usr/include/stdlib.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- float -->
      <return type-id='type-id-1343'/>
    </function-decl>
    <!-- long double strtold(const char*, char**) -->
    <function-decl name='strtold' filepath='/usr/include/stdlib.h' line='176' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'char**' -->
      <parameter type-id='type-id-119'/>
      <!-- long double -->
      <return type-id='type-id-1348'/>
    </function-decl>
    <!-- wint_t btowc(int) -->
    <function-decl name='btowc' filepath='/usr/include/wchar.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- wint_t fgetwc(__FILE*) -->
    <function-decl name='fgetwc' filepath='/usr/include/wchar.h' line='743' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- wchar_t* fgetws(wchar_t*, int, __FILE*) -->
    <function-decl name='fgetws' filepath='/usr/include/wchar.h' line='772' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- wint_t fputwc(wchar_t, __FILE*) -->
    <function-decl name='fputwc' filepath='/usr/include/wchar.h' line='757' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- int fputws(const wchar_t*, __FILE*) -->
    <function-decl name='fputws' filepath='/usr/include/wchar.h' line='779' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int fwide(__FILE*, int) -->
    <function-decl name='fwide' filepath='/usr/include/wchar.h' line='585' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int fwprintf(__FILE*, const wchar_t*, ...) -->
    <function-decl name='fwprintf' filepath='/usr/include/wchar.h' line='592' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int fwscanf(__FILE*, const wchar_t*, ...) -->
    <function-decl name='fwscanf' filepath='/usr/include/wchar.h' line='633' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- wint_t getwc(__FILE*) -->
    <function-decl name='getwc' filepath='/usr/include/wchar.h' line='744' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- wint_t getwchar() -->
    <function-decl name='getwchar' filepath='/usr/include/wchar.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- size_t mbrlen(const char*, size_t, mbstate_t*) -->
    <function-decl name='mbrlen' filepath='/usr/include/wchar.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'mbstate_t*' -->
      <parameter type-id='type-id-1461'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- size_t mbrtowc(wchar_t*, const char*, size_t, mbstate_t*) -->
    <function-decl name='mbrtowc' filepath='/usr/include/wchar.h' line='363' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'mbstate_t*' -->
      <parameter type-id='type-id-1461'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- int mbsinit(const mbstate_t*) -->
    <function-decl name='mbsinit' filepath='/usr/include/wchar.h' line='359' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const mbstate_t*' -->
      <parameter type-id='type-id-1428'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- size_t mbsrtowcs(wchar_t*, const char**, size_t, mbstate_t*) -->
    <function-decl name='mbsrtowcs' filepath='/usr/include/wchar.h' line='406' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const char**' -->
      <parameter type-id='type-id-1426'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'mbstate_t*' -->
      <parameter type-id='type-id-1461'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- wint_t putwc(wchar_t, __FILE*) -->
    <function-decl name='putwc' filepath='/usr/include/wchar.h' line='758' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- wint_t putwchar(wchar_t) -->
    <function-decl name='putwchar' filepath='/usr/include/wchar.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- int swprintf(wchar_t*, size_t, const wchar_t*, ...) -->
    <function-decl name='swprintf' filepath='/usr/include/wchar.h' line='602' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int swscanf(const wchar_t*, const wchar_t*, ...) -->
    <function-decl name='swscanf' filepath='/usr/include/wchar.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- wint_t ungetwc(wint_t, __FILE*) -->
    <function-decl name='ungetwc' filepath='/usr/include/wchar.h' line='787' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'typedef wint_t' -->
      <parameter type-id='type-id-1380'/>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- typedef wint_t -->
      <return type-id='type-id-1380'/>
    </function-decl>
    <!-- int vfwprintf(__FILE*, const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vfwprintf' filepath='/usr/include/wchar.h' line='610' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int vfwscanf(__FILE*, const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vfwscanf' filepath='/usr/include/wchar.h' line='687' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type '__FILE*' -->
      <parameter type-id='type-id-1418'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int vswprintf(wchar_t*, size_t, const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vswprintf' filepath='/usr/include/wchar.h' line='623' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int vswscanf(const wchar_t*, const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vswscanf' filepath='/usr/include/wchar.h' line='699' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int vwprintf(const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vwprintf' filepath='/usr/include/wchar.h' line='618' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int vwscanf(const wchar_t*, typedef __va_list_tag __va_list_tag*) -->
    <function-decl name='vwscanf' filepath='/usr/include/wchar.h' line='695' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef __va_list_tag __va_list_tag*' -->
      <parameter type-id='type-id-67'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- size_t wcrtomb(char*, wchar_t, mbstate_t*) -->
    <function-decl name='wcrtomb' filepath='/usr/include/wchar.h' line='368' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- parameter of type 'mbstate_t*' -->
      <parameter type-id='type-id-1461'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- wchar_t* wcscat(wchar_t*, const wchar_t*) -->
    <function-decl name='wcscat' filepath='/usr/include/wchar.h' line='152' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- int wcscmp(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcscmp' filepath='/usr/include/wchar.h' line='160' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int wcscoll(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcscoll' filepath='/usr/include/wchar.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- wchar_t* wcscpy(wchar_t*, const wchar_t*) -->
    <function-decl name='wcscpy' filepath='/usr/include/wchar.h' line='144' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- size_t wcscspn(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcscspn' filepath='/usr/include/wchar.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- size_t wcsftime(wchar_t*, size_t, const wchar_t*, const tm*) -->
    <function-decl name='wcsftime' filepath='/usr/include/wchar.h' line='853' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const tm*' -->
      <parameter type-id='type-id-1455'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- size_t wcslen(const wchar_t*) -->
    <function-decl name='wcslen' filepath='/usr/include/wchar.h' line='284' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- wchar_t* wcsncat(wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wcsncat' filepath='/usr/include/wchar.h' line='155' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- int wcsncmp(const wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wcsncmp' filepath='/usr/include/wchar.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- wchar_t* wcsncpy(wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wcsncpy' filepath='/usr/include/wchar.h' line='147' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- size_t wcsrtombs(char*, const wchar_t**, size_t, mbstate_t*) -->
    <function-decl name='wcsrtombs' filepath='/usr/include/wchar.h' line='412' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'char*' -->
      <parameter type-id='type-id-113'/>
      <!-- parameter of type 'const wchar_t**' -->
      <parameter type-id='type-id-1458'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'mbstate_t*' -->
      <parameter type-id='type-id-1461'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- size_t wcsspn(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcsspn' filepath='/usr/include/wchar.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- double wcstod(const wchar_t*, wchar_t**) -->
    <function-decl name='wcstod' filepath='/usr/include/wchar.h' line='448' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- double -->
      <return type-id='type-id-2'/>
    </function-decl>
    <!-- float wcstof(const wchar_t*, wchar_t**) -->
    <function-decl name='wcstof' filepath='/usr/include/wchar.h' line='455' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- float -->
      <return type-id='type-id-1343'/>
    </function-decl>
    <!-- wchar_t* wcstok(wchar_t*, const wchar_t*, wchar_t**) -->
    <function-decl name='wcstok' filepath='/usr/include/wchar.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- long int wcstol(const wchar_t*, wchar_t**, int) -->
    <function-decl name='wcstol' filepath='/usr/include/wchar.h' line='466' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long int -->
      <return type-id='type-id-80'/>
    </function-decl>
    <!-- unsigned long int wcstoul(const wchar_t*, wchar_t**, int) -->
    <function-decl name='wcstoul' filepath='/usr/include/wchar.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- unsigned long int -->
      <return type-id='type-id-5'/>
    </function-decl>
    <!-- size_t wcsxfrm(wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wcsxfrm' filepath='/usr/include/wchar.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- int wctob(wint_t) -->
    <function-decl name='wctob' filepath='/usr/include/wchar.h' line='355' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'typedef wint_t' -->
      <parameter type-id='type-id-1380'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int wmemcmp(const wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wmemcmp' filepath='/usr/include/wchar.h' line='322' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- wchar_t* wmemcpy(wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wmemcpy' filepath='/usr/include/wchar.h' line='327' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- wchar_t* wmemmove(wchar_t*, const wchar_t*, size_t) -->
    <function-decl name='wmemmove' filepath='/usr/include/wchar.h' line='332' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- wchar_t* wmemset(wchar_t*, wchar_t, size_t) -->
    <function-decl name='wmemset' filepath='/usr/include/wchar.h' line='336' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'wchar_t*' -->
      <parameter type-id='type-id-1496'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- wchar_t* -->
      <return type-id='type-id-1496'/>
    </function-decl>
    <!-- int wprintf(const wchar_t*, ...) -->
    <function-decl name='wprintf' filepath='/usr/include/wchar.h' line='599' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int wscanf(const wchar_t*, ...) -->
    <function-decl name='wscanf' filepath='/usr/include/wchar.h' line='640' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <parameter is-variadic='yes'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- const wchar_t* wcschr(const wchar_t*, wchar_t) -->
    <function-decl name='wcschr' mangled-name='*wcschr' filepath='/usr/include/wchar.h' line='221' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- const wchar_t* -->
      <return type-id='type-id-1457'/>
    </function-decl>
    <!-- const wchar_t* wcspbrk(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcspbrk' mangled-name='*wcspbrk' filepath='/usr/include/wchar.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- const wchar_t* -->
      <return type-id='type-id-1457'/>
    </function-decl>
    <!-- const wchar_t* wcsrchr(const wchar_t*, wchar_t) -->
    <function-decl name='wcsrchr' mangled-name='*wcsrchr' filepath='/usr/include/wchar.h' line='231' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- const wchar_t* -->
      <return type-id='type-id-1457'/>
    </function-decl>
    <!-- const wchar_t* wcsstr(const wchar_t*, const wchar_t*) -->
    <function-decl name='wcsstr' mangled-name='*wcsstr' filepath='/usr/include/wchar.h' line='270' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- const wchar_t* -->
      <return type-id='type-id-1457'/>
    </function-decl>
    <!-- const wchar_t* wmemchr(const wchar_t*, wchar_t, size_t) -->
    <function-decl name='wmemchr' mangled-name='*wmemchr' filepath='/usr/include/wchar.h' line='313' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t' -->
      <parameter type-id='type-id-1366'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- const wchar_t* -->
      <return type-id='type-id-1457'/>
    </function-decl>
    <!-- long double wcstold(const wchar_t*, wchar_t**) -->
    <function-decl name='wcstold' filepath='/usr/include/wchar.h' line='457' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- long double -->
      <return type-id='type-id-1348'/>
    </function-decl>
    <!-- long long int wcstoll(const wchar_t*, wchar_t**, int) -->
    <function-decl name='wcstoll' filepath='/usr/include/wchar.h' line='481' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long long int -->
      <return type-id='type-id-1029'/>
    </function-decl>
    <!-- long long unsigned int wcstoull(const wchar_t*, wchar_t**, int) -->
    <function-decl name='wcstoull' filepath='/usr/include/wchar.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'const wchar_t*' -->
      <parameter type-id='type-id-1457'/>
      <!-- parameter of type 'wchar_t**' -->
      <parameter type-id='type-id-1497'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- long long unsigned int -->
      <return type-id='type-id-1030'/>
    </function-decl>
    <!-- char* setlocale(int, const char*) -->
    <function-decl name='setlocale' filepath='/usr/include/locale.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1'/>
      <!-- parameter of type 'const char*' -->
      <parameter type-id='type-id-52'/>
      <!-- char* -->
      <return type-id='type-id-113'/>
    </function-decl>
    <!-- lconv* localeconv() -->
    <function-decl name='localeconv' filepath='/usr/include/locale.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64'>
      <!-- lconv* -->
      <return type-id='type-id-1460'/>
    </function-decl>
    <!-- namespace base -->
    <namespace-decl name='base'>
      <!-- enum base::LinkerInitialized -->
      <enum-decl name='LinkerInitialized' filepath='src/base/basictypes.h' line='381' column='1' id='type-id-90'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='LINKER_INITIALIZED' value='0'/>
      </enum-decl>
      <!-- struct base::MallocRange -->
      <class-decl name='MallocRange' size-in-bits='256' is-struct='yes' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='399' column='1' id='type-id-1419'>
        <member-type access='public'>
          <!-- enum base::MallocRange::Type -->
          <enum-decl name='Type' filepath='./src/gperftools/malloc_extension.h' line='400' column='1' id='type-id-1505'>
            <underlying-type type-id='type-id-84'/>
            <enumerator name='INUSE' value='0'/>
            <enumerator name='FREE' value='1'/>
            <enumerator name='UNMAPPED' value='2'/>
            <enumerator name='UNKNOWN' value='3'/>
          </enum-decl>
        </member-type>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- uintptr_t base::MallocRange::address -->
          <var-decl name='address' type-id='type-id-145' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='408' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- size_t base::MallocRange::length -->
          <var-decl name='length' type-id='type-id-57' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='409' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- base::MallocRange::Type base::MallocRange::type -->
          <var-decl name='type' type-id='type-id-1505' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='410' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='192'>
          <!-- double base::MallocRange::fraction -->
          <var-decl name='fraction' type-id='type-id-2' visibility='default' filepath='./src/gperftools/malloc_extension.h' line='411' column='1'/>
        </data-member>
      </class-decl>
      <!-- namespace base::internal -->
      <namespace-decl name='internal'>
        <!-- struct base::internal::HookList<void (*)(const void*, size_t)> -->
        <class-decl name='HookList&lt;void (*)(const void*, size_t)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='./src/malloc_hook-inl.h' line='59' column='1' id='type-id-1075'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*, size_t)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::Add(void (void*, typedef size_t)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE3AddES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*, size_t)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE18FixupPrivEndLockedEv'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::Remove(void (void*, typedef size_t)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE6RemoveES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*, size_t)>::Traverse(void (void*, typedef size_t)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE8TraverseEPS5_i'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)**' -->
              <parameter type-id='type-id-1086'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*, size_t)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE5emptyEv'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t)* base::internal::HookList<void (*)(const void*, size_t)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvmEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZNK4base8internal8HookListIPFvPKvmEE11GetSingularEv'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1085' is-artificial='yes'/>
              <!-- void (void*, typedef size_t)* -->
              <return type-id='type-id-381'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*, typedef size_t)* base::internal::HookList<void (*)(const void*, size_t)>::ExchangeSingular(void (void*, typedef size_t)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvmEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN4base8internal8HookListIPFvPKvmEE16ExchangeSingularES5_'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*, size_t)>*' -->
              <parameter type-id='type-id-1084' is-artificial='yes'/>
              <!-- parameter of type 'void (void*, typedef size_t)*' -->
              <parameter type-id='type-id-381'/>
              <!-- void (void*, typedef size_t)* -->
              <return type-id='type-id-381'/>
            </function-decl>
          </member-function>
        </class-decl>
        <!-- struct base::internal::HookList<void (*)(const void*)> -->
        <class-decl name='HookList&lt;void (*)(const void*)&gt;' size-in-bits='576' is-struct='yes' visibility='default' filepath='./src/malloc_hook-inl.h' line='59' column='1' id='type-id-1076'>
          <data-member access='public' layout-offset-in-bits='0'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*)>::priv_end -->
            <var-decl name='priv_end' type-id='type-id-798' visibility='default' filepath='src/malloc_hook-inl.h' line='101' column='1'/>
          </data-member>
          <data-member access='public' layout-offset-in-bits='64'>
            <!-- AtomicWord base::internal::HookList<void (*)(const void*)>::priv_data[8] -->
            <var-decl name='priv_data' type-id='type-id-799' visibility='default' filepath='src/malloc_hook-inl.h' line='102' column='1'/>
          </data-member>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::Add(void (void*)*) -->
            <function-decl name='Add' mangled-name='_ZN4base8internal8HookListIPFvPKvEE3AddES5_' filepath='src/malloc_hook-inl.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void base::internal::HookList<void (*)(const void*)>::FixupPrivEndLocked() -->
            <function-decl name='FixupPrivEndLocked' mangled-name='_ZN4base8internal8HookListIPFvPKvEE18FixupPrivEndLockedEv' filepath='src/malloc_hook-inl.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- void -->
              <return type-id='type-id-56'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::Remove(void (void*)*) -->
            <function-decl name='Remove' mangled-name='_ZN4base8internal8HookListIPFvPKvEE6RemoveES5_' filepath='src/malloc_hook-inl.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- int base::internal::HookList<void (*)(const void*)>::Traverse(void (void*)**, int) -->
            <function-decl name='Traverse' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE8TraverseEPS5_i' filepath='src/malloc_hook-inl.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)**' -->
              <parameter type-id='type-id-1083'/>
              <!-- parameter of type 'int' -->
              <parameter type-id='type-id-1'/>
              <!-- int -->
              <return type-id='type-id-1'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- bool base::internal::HookList<void (*)(const void*)>::empty() -->
            <function-decl name='empty' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE5emptyEv' filepath='src/malloc_hook-inl.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- bool -->
              <return type-id='type-id-55'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*)* base::internal::HookList<void (*)(const void*)>::GetSingular() -->
            <function-decl name='GetSingular' mangled-name='_ZNK4base8internal8HookListIPFvPKvEE11GetSingularEv' filepath='src/malloc_hook-inl.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'const base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1082' is-artificial='yes'/>
              <!-- void (void*)* -->
              <return type-id='type-id-240'/>
            </function-decl>
          </member-function>
          <member-function access='public'>
            <!-- void (void*)* base::internal::HookList<void (*)(const void*)>::ExchangeSingular(void (void*)*) -->
            <function-decl name='ExchangeSingular' mangled-name='_ZN4base8internal8HookListIPFvPKvEE16ExchangeSingularES5_' filepath='src/malloc_hook-inl.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
              <!-- implicit parameter of type 'base::internal::HookList<void (*)(const void*)>*' -->
              <parameter type-id='type-id-1081' is-artificial='yes'/>
              <!-- parameter of type 'void (void*)*' -->
              <parameter type-id='type-id-240'/>
              <!-- void (void*)* -->
              <return type-id='type-id-240'/>
            </function-decl>
          </member-function>
        </class-decl>
      </namespace-decl>
      <!-- namespace base::subtle -->
      <namespace-decl name='subtle'>
        <!-- typedef int64_t base::subtle::Atomic64 -->
        <typedef-decl name='Atomic64' type-id='type-id-98' filepath='./src/base/atomicops-internals-x86.h' line='70' column='1' id='type-id-1077'/>
        <!-- Atomic32 base::subtle::NoBarrier_AtomicExchange(volatile Atomic32*, Atomic32) -->
        <function-decl name='NoBarrier_AtomicExchange' filepath='./src/base/atomicops-internals-x86.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
        <!-- Atomic32 base::subtle::NoBarrier_CompareAndSwap(volatile Atomic32*, Atomic32, Atomic32) -->
        <function-decl name='NoBarrier_CompareAndSwap' filepath='./src/base/atomicops-internals-x86.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
        <!-- base::subtle::Atomic64 base::subtle::NoBarrier_Load(const volatile base::subtle::Atomic64*) -->
        <function-decl name='NoBarrier_Load' filepath='./src/base/atomicops-internals-x86.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const volatile base::subtle::Atomic64*' -->
          <parameter type-id='type-id-1078'/>
          <!-- typedef base::subtle::Atomic64 -->
          <return type-id='type-id-1077'/>
        </function-decl>
        <!-- Atomic32 base::subtle::Acquire_CompareAndSwap(volatile Atomic32*, Atomic32, Atomic32) -->
        <function-decl name='Acquire_CompareAndSwap' filepath='./src/base/atomicops-internals-x86.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
        <!-- Atomic32 base::subtle::Release_AtomicExchange(volatile Atomic32*, Atomic32) -->
        <function-decl name='Release_AtomicExchange' filepath='./src/base/atomicops-internals-x86.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'volatile Atomic32*' -->
          <parameter type-id='type-id-103'/>
          <!-- parameter of type 'typedef Atomic32' -->
          <parameter type-id='type-id-95'/>
          <!-- typedef Atomic32 -->
          <return type-id='type-id-95'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- class tcmalloc::CentralFreeList -->
      <class-decl name='CentralFreeList' size-in-bits='9344' visibility='default' filepath='src/central_freelist.h' line='50' column='1' id='type-id-1466'>
        <member-type access='private'>
          <!-- struct tcmalloc::CentralFreeList::TCEntry -->
          <class-decl name='TCEntry' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/central_freelist.h' line='97' column='1' id='type-id-1351'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- void* tcmalloc::CentralFreeList::TCEntry::head -->
              <var-decl name='head' type-id='type-id-53' visibility='default' filepath='src/central_freelist.h' line='98' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- void* tcmalloc::CentralFreeList::TCEntry::tail -->
              <var-decl name='tail' type-id='type-id-53' visibility='default' filepath='src/central_freelist.h' line='99' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::CentralFreeList::kMaxNumTransferEntries -->
          <var-decl name='kMaxNumTransferEntries' type-id='type-id-134' visibility='default' filepath='src/central_freelist.h' line='111' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- SpinLock tcmalloc::CentralFreeList::lock_ -->
          <var-decl name='lock_' type-id='type-id-82' visibility='default' filepath='src/central_freelist.h' line='164' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::CentralFreeList::size_class_ -->
          <var-decl name='size_class_' type-id='type-id-57' visibility='default' filepath='src/central_freelist.h' line='167' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- tcmalloc::Span tcmalloc::CentralFreeList::empty_ -->
          <var-decl name='empty_' type-id='type-id-138' visibility='default' filepath='src/central_freelist.h' line='168' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='512'>
          <!-- tcmalloc::Span tcmalloc::CentralFreeList::nonempty_ -->
          <var-decl name='nonempty_' type-id='type-id-138' visibility='default' filepath='src/central_freelist.h' line='169' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='896'>
          <!-- size_t tcmalloc::CentralFreeList::num_spans_ -->
          <var-decl name='num_spans_' type-id='type-id-57' visibility='default' filepath='src/central_freelist.h' line='170' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='960'>
          <!-- size_t tcmalloc::CentralFreeList::counter_ -->
          <var-decl name='counter_' type-id='type-id-57' visibility='default' filepath='src/central_freelist.h' line='171' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='1024'>
          <!-- tcmalloc::CentralFreeList::TCEntry tcmalloc::CentralFreeList::tc_slots_[64] -->
          <var-decl name='tc_slots_' type-id='type-id-1352' visibility='default' filepath='src/central_freelist.h' line='178' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='9216'>
          <!-- int32_t tcmalloc::CentralFreeList::used_slots_ -->
          <var-decl name='used_slots_' type-id='type-id-71' visibility='default' filepath='src/central_freelist.h' line='182' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='9248'>
          <!-- int32_t tcmalloc::CentralFreeList::cache_size_ -->
          <var-decl name='cache_size_' type-id='type-id-71' visibility='default' filepath='src/central_freelist.h' line='186' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='9280'>
          <!-- int32_t tcmalloc::CentralFreeList::max_cache_size_ -->
          <var-decl name='max_cache_size_' type-id='type-id-71' visibility='default' filepath='src/central_freelist.h' line='188' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::CentralFreeList::CentralFreeList() -->
          <function-decl name='CentralFreeList' filepath='src/central_freelist.h' line='55' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::Init(size_t) -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc15CentralFreeList4InitEm' filepath='src/central_freelist.h' line='57' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList4InitEm'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::InsertRange(void*, void*, int) -->
          <function-decl name='InsertRange' mangled-name='_ZN8tcmalloc15CentralFreeList11InsertRangeEPvS1_i' filepath='src/central_freelist.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList11InsertRangeEPvS1_i'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::CentralFreeList::RemoveRange(void**, void**, int) -->
          <function-decl name='RemoveRange' mangled-name='_ZN8tcmalloc15CentralFreeList11RemoveRangeEPPvS2_i' filepath='src/central_freelist.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList11RemoveRangeEPPvS2_i'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::CentralFreeList::length() -->
          <function-decl name='length' mangled-name='_ZN8tcmalloc15CentralFreeList6lengthEv' filepath='src/central_freelist.h' line='69' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::CentralFreeList::tc_length() -->
          <function-decl name='tc_length' mangled-name='_ZN8tcmalloc15CentralFreeList9tc_lengthEv' filepath='src/central_freelist.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList9tc_lengthEv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::CentralFreeList::OverheadBytes() -->
          <function-decl name='OverheadBytes' mangled-name='_ZN8tcmalloc15CentralFreeList13OverheadBytesEv' filepath='src/central_freelist.h' line='81' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList13OverheadBytesEv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::Lock() -->
          <function-decl name='Lock' mangled-name='_ZN8tcmalloc15CentralFreeList4LockEv' filepath='src/central_freelist.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::Unlock() -->
          <function-decl name='Unlock' mangled-name='_ZN8tcmalloc15CentralFreeList6UnlockEv' filepath='src/central_freelist.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::CentralFreeList::FetchFromOneSpans(int, void**, void**) -->
          <function-decl name='FetchFromOneSpans' mangled-name='_ZN8tcmalloc15CentralFreeList17FetchFromOneSpansEiPPvS2_' filepath='src/central_freelist.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList17FetchFromOneSpansEiPPvS2_'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::CentralFreeList::FetchFromOneSpansSafe(int, void**, void**) -->
          <function-decl name='FetchFromOneSpansSafe' mangled-name='_ZN8tcmalloc15CentralFreeList21FetchFromOneSpansSafeEiPPvS2_' filepath='src/central_freelist.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList21FetchFromOneSpansSafeEiPPvS2_'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- parameter of type 'void**' -->
            <parameter type-id='type-id-141'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::ReleaseListToSpans(void*) -->
          <function-decl name='ReleaseListToSpans' mangled-name='_ZN8tcmalloc15CentralFreeList18ReleaseListToSpansEPv' filepath='src/central_freelist.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList18ReleaseListToSpansEPv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::ReleaseToSpans(void*) -->
          <function-decl name='ReleaseToSpans' mangled-name='_ZN8tcmalloc15CentralFreeList14ReleaseToSpansEPv' filepath='src/central_freelist.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList14ReleaseToSpansEPv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::CentralFreeList::Populate() -->
          <function-decl name='Populate' mangled-name='_ZN8tcmalloc15CentralFreeList8PopulateEv' filepath='src/central_freelist.h' line='138' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList8PopulateEv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::CentralFreeList::MakeCacheSpace() -->
          <function-decl name='MakeCacheSpace' mangled-name='_ZN8tcmalloc15CentralFreeList14MakeCacheSpaceEv' filepath='src/central_freelist.h' line='144' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList14MakeCacheSpaceEv'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- bool tcmalloc::CentralFreeList::EvictRandomSizeClass(bool) -->
          <function-decl name='EvictRandomSizeClass' mangled-name='_ZN8tcmalloc15CentralFreeList20EvictRandomSizeClassEib' filepath='src/central_freelist.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList20EvictRandomSizeClassEib'>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'bool' -->
            <parameter type-id='type-id-55'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::CentralFreeList::ShrinkCache(int, bool) -->
          <function-decl name='ShrinkCache' mangled-name='_ZN8tcmalloc15CentralFreeList11ShrinkCacheEib' filepath='src/central_freelist.h' line='160' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc15CentralFreeList11ShrinkCacheEib'>
            <!-- implicit parameter of type 'tcmalloc::CentralFreeList*' -->
            <parameter type-id='type-id-1467' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- parameter of type 'bool' -->
            <parameter type-id='type-id-55'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::CentralFreeListPaddedTo<16> -->
      <class-decl name='CentralFreeListPaddedTo&lt;16&gt;' size-in-bits='9728' visibility='default' filepath='src/central_freelist.h' line='196' column='1' id='type-id-1506'>
        <!-- class tcmalloc::CentralFreeList -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1466'/>
        <data-member access='private' layout-offset-in-bits='9312'>
          <!-- char tcmalloc::CentralFreeListPaddedTo<16>::pad_[48] -->
          <var-decl name='pad_' type-id='type-id-191' visibility='default' filepath='src/central_freelist.h' line='198' column='1'/>
        </data-member>
      </class-decl>
      <!-- class tcmalloc::Sampler -->
      <class-decl name='Sampler' size-in-bits='128' visibility='default' filepath='src/sampler.h' line='103' column='1' id='type-id-1479'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- size_t tcmalloc::Sampler::bytes_until_sample_ -->
          <var-decl name='bytes_until_sample_' type-id='type-id-57' visibility='default' filepath='src/sampler.h' line='130' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- uint64_t tcmalloc::Sampler::rnd_ -->
          <var-decl name='rnd_' type-id='type-id-15' visibility='default' filepath='src/sampler.h' line='131' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::Sampler::kFastlogNumBits -->
          <var-decl name='kFastlogNumBits' type-id='type-id-134' visibility='default' filepath='src/sampler.h' line='136' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::Sampler::kFastlogMask -->
          <var-decl name='kFastlogMask' type-id='type-id-134' visibility='default' filepath='src/sampler.h' line='137' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static double tcmalloc::Sampler::log_table_[1024] -->
          <var-decl name='log_table_' type-id='type-id-1342' mangled-name='_ZN8tcmalloc7Sampler10log_table_E' visibility='default' filepath='src/sampler.h' line='138' column='1' elf-symbol-id='_ZN8tcmalloc7Sampler10log_table_E'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::Sampler::Init(uint32_t) -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc7Sampler4InitEj' filepath='src/sampler.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7Sampler4InitEj'>
            <!-- implicit parameter of type 'tcmalloc::Sampler*' -->
            <parameter type-id='type-id-1480' is-artificial='yes'/>
            <!-- parameter of type 'typedef uint32_t' -->
            <parameter type-id='type-id-12'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::Sampler::Cleanup() -->
          <function-decl name='Cleanup' mangled-name='_ZN8tcmalloc7Sampler7CleanupEv' filepath='src/sampler.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::Sampler*' -->
            <parameter type-id='type-id-1480' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::Sampler::SampleAllocation(size_t) -->
          <function-decl name='SampleAllocation' mangled-name='_ZN8tcmalloc7Sampler16SampleAllocationEm' filepath='src/sampler.h' line='113' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::Sampler*' -->
            <parameter type-id='type-id-1480' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::Sampler::PickNextSamplingPoint() -->
          <function-decl name='PickNextSamplingPoint' mangled-name='_ZN8tcmalloc7Sampler21PickNextSamplingPointEv' filepath='src/sampler.h' line='116' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7Sampler21PickNextSamplingPointEv'>
            <!-- implicit parameter of type 'tcmalloc::Sampler*' -->
            <parameter type-id='type-id-1480' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::Sampler::InitStatics() -->
          <function-decl name='InitStatics' mangled-name='_ZN8tcmalloc7Sampler11InitStaticsEv' filepath='src/sampler.h' line='119' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7Sampler11InitStaticsEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::Sampler::GetSamplePeriod() -->
          <function-decl name='GetSamplePeriod' mangled-name='_ZN8tcmalloc7Sampler15GetSamplePeriodEv' filepath='src/sampler.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7Sampler15GetSamplePeriodEv'>
            <!-- implicit parameter of type 'tcmalloc::Sampler*' -->
            <parameter type-id='type-id-1480' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- uint64_t tcmalloc::Sampler::NextRandom() -->
          <function-decl name='NextRandom' mangled-name='_ZN8tcmalloc7Sampler10NextRandomEm' filepath='src/sampler.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef uint64_t' -->
            <parameter type-id='type-id-15'/>
            <!-- typedef uint64_t -->
            <return type-id='type-id-15'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- double tcmalloc::Sampler::FastLog2() -->
          <function-decl name='FastLog2' mangled-name='_ZN8tcmalloc7Sampler8FastLog2ERKd' filepath='src/sampler.h' line='126' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'const double&' -->
            <parameter type-id='type-id-1229'/>
            <!-- double -->
            <return type-id='type-id-2'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::Sampler::PopulateFastLog2Table() -->
          <function-decl name='PopulateFastLog2Table' mangled-name='_ZN8tcmalloc7Sampler21PopulateFastLog2TableEv' filepath='src/sampler.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7Sampler21PopulateFastLog2TableEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::CentralFreeListPadded -->
      <class-decl name='CentralFreeListPadded' size-in-bits='9728' visibility='default' filepath='src/central_freelist.h' line='206' column='1' id='type-id-1353'>
        <!-- class tcmalloc::CentralFreeListPaddedTo<16> -->
        <base-class access='public' layout-offset-in-bits='0' type-id='type-id-1506'/>
      </class-decl>
      <!-- class tcmalloc::ThreadCache -->
      <class-decl name='ThreadCache' size-in-bits='17408' visibility='default' filepath='src/thread_cache.h' line='66' column='1' id='type-id-1449'>
        <member-type access='private'>
          <!-- class tcmalloc::ThreadCache::FreeList -->
          <class-decl name='FreeList' size-in-bits='192' visibility='default' filepath='src/thread_cache.h' line='132' column='1' id='type-id-1357'>
            <data-member access='private' layout-offset-in-bits='0'>
              <!-- void* tcmalloc::ThreadCache::FreeList::list_ -->
              <var-decl name='list_' type-id='type-id-53' visibility='default' filepath='src/thread_cache.h' line='134' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='64'>
              <!-- uint32_t tcmalloc::ThreadCache::FreeList::length_ -->
              <var-decl name='length_' type-id='type-id-12' visibility='default' filepath='src/thread_cache.h' line='138' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='96'>
              <!-- uint32_t tcmalloc::ThreadCache::FreeList::lowater_ -->
              <var-decl name='lowater_' type-id='type-id-12' visibility='default' filepath='src/thread_cache.h' line='139' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='128'>
              <!-- uint32_t tcmalloc::ThreadCache::FreeList::max_length_ -->
              <var-decl name='max_length_' type-id='type-id-12' visibility='default' filepath='src/thread_cache.h' line='140' column='1'/>
            </data-member>
            <data-member access='private' layout-offset-in-bits='160'>
              <!-- uint32_t tcmalloc::ThreadCache::FreeList::length_overages_ -->
              <var-decl name='length_overages_' type-id='type-id-12' visibility='default' filepath='src/thread_cache.h' line='144' column='1'/>
            </data-member>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::Init() -->
              <function-decl name='Init' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList4InitEv' filepath='src/thread_cache.h' line='154' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- size_t tcmalloc::ThreadCache::FreeList::length() -->
              <function-decl name='length' mangled-name='_ZNK8tcmalloc11ThreadCache8FreeList6lengthEv' filepath='src/thread_cache.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1453' is-artificial='yes'/>
                <!-- typedef size_t -->
                <return type-id='type-id-57'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- size_t tcmalloc::ThreadCache::FreeList::max_length() -->
              <function-decl name='max_length' mangled-name='_ZNK8tcmalloc11ThreadCache8FreeList10max_lengthEv' filepath='src/thread_cache.h' line='168' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1453' is-artificial='yes'/>
                <!-- typedef size_t -->
                <return type-id='type-id-57'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::set_max_length(size_t) -->
              <function-decl name='set_max_length' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList14set_max_lengthEm' filepath='src/thread_cache.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- parameter of type 'typedef size_t' -->
                <parameter type-id='type-id-57'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- size_t tcmalloc::ThreadCache::FreeList::length_overages() -->
              <function-decl name='length_overages' mangled-name='_ZNK8tcmalloc11ThreadCache8FreeList15length_overagesEv' filepath='src/thread_cache.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1453' is-artificial='yes'/>
                <!-- typedef size_t -->
                <return type-id='type-id-57'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::set_length_overages(size_t) -->
              <function-decl name='set_length_overages' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList19set_length_overagesEm' filepath='src/thread_cache.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- parameter of type 'typedef size_t' -->
                <parameter type-id='type-id-57'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- bool tcmalloc::ThreadCache::FreeList::empty() -->
              <function-decl name='empty' mangled-name='_ZNK8tcmalloc11ThreadCache8FreeList5emptyEv' filepath='src/thread_cache.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1453' is-artificial='yes'/>
                <!-- bool -->
                <return type-id='type-id-55'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- int tcmalloc::ThreadCache::FreeList::lowwatermark() -->
              <function-decl name='lowwatermark' mangled-name='_ZNK8tcmalloc11ThreadCache8FreeList12lowwatermarkEv' filepath='src/thread_cache.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'const tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1453' is-artificial='yes'/>
                <!-- int -->
                <return type-id='type-id-1'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::clear_lowwatermark() -->
              <function-decl name='clear_lowwatermark' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList18clear_lowwatermarkEv' filepath='src/thread_cache.h' line='194' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::Push(void*) -->
              <function-decl name='Push' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList4PushEPv' filepath='src/thread_cache.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- parameter of type 'void*' -->
                <parameter type-id='type-id-53'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void* tcmalloc::ThreadCache::FreeList::Pop() -->
              <function-decl name='Pop' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList3PopEv' filepath='src/thread_cache.h' line='201' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- void* -->
                <return type-id='type-id-53'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void* tcmalloc::ThreadCache::FreeList::Next() -->
              <function-decl name='Next' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList4NextEv' filepath='src/thread_cache.h' line='208' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- void* -->
                <return type-id='type-id-53'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::PushRange(int, void*, void*) -->
              <function-decl name='PushRange' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList9PushRangeEiPvS2_' filepath='src/thread_cache.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- parameter of type 'int' -->
                <parameter type-id='type-id-1'/>
                <!-- parameter of type 'void*' -->
                <parameter type-id='type-id-53'/>
                <!-- parameter of type 'void*' -->
                <parameter type-id='type-id-53'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
            <member-function access='private'>
              <!-- void tcmalloc::ThreadCache::FreeList::PopRange(int, void**, void**) -->
              <function-decl name='PopRange' mangled-name='_ZN8tcmalloc11ThreadCache8FreeList8PopRangeEiPPvS3_' filepath='src/thread_cache.h' line='217' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
                <parameter type-id='type-id-1485' is-artificial='yes'/>
                <!-- parameter of type 'int' -->
                <parameter type-id='type-id-1'/>
                <!-- parameter of type 'void**' -->
                <parameter type-id='type-id-141'/>
                <!-- parameter of type 'void**' -->
                <parameter type-id='type-id-141'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct tcmalloc::ThreadCache::ThreadLocalData -->
          <class-decl name='ThreadLocalData' size-in-bits='128' is-struct='yes' visibility='default' filepath='src/thread_cache.h' line='262' column='1' id='type-id-1507'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::ThreadLocalData::heap -->
              <var-decl name='heap' type-id='type-id-1484' visibility='default' filepath='src/thread_cache.h' line='263' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- size_t tcmalloc::ThreadCache::ThreadLocalData::min_size_for_slow_path -->
              <var-decl name='min_size_for_slow_path' type-id='type-id-57' visibility='default' filepath='src/thread_cache.h' line='270' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- enum tcmalloc::ThreadCache::__anonymous_enum__ -->
          <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='src/thread_cache.h' line='69' column='1' id='type-id-1508'>
            <underlying-type type-id='type-id-84'/>
            <enumerator name='have_tls' value='1'/>
          </enum-decl>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::next_ -->
          <var-decl name='next_' type-id='type-id-1484' visibility='default' filepath='src/thread_cache.h' line='75' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::prev_ -->
          <var-decl name='prev_' type-id='type-id-1484' visibility='default' filepath='src/thread_cache.h' line='76' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::ThreadCache::ThreadLocalData tcmalloc::ThreadCache::threadlocal_data_ -->
          <var-decl name='threadlocal_data_' type-id='type-id-1507' mangled-name='_ZN8tcmalloc11ThreadCache17threadlocal_data_E' visibility='default' filepath='src/thread_cache.h' line='272' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache17threadlocal_data_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static bool tcmalloc::ThreadCache::tsd_inited_ -->
          <var-decl name='tsd_inited_' type-id='type-id-55' mangled-name='_ZN8tcmalloc11ThreadCache11tsd_inited_E' visibility='default' filepath='src/thread_cache.h' line='280' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache11tsd_inited_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static pthread_key_t tcmalloc::ThreadCache::heap_key_ -->
          <var-decl name='heap_key_' type-id='type-id-1089' mangled-name='_ZN8tcmalloc11ThreadCache9heap_key_E' visibility='default' filepath='src/thread_cache.h' line='281' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache9heap_key_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::ThreadCache* tcmalloc::ThreadCache::thread_heaps_ -->
          <var-decl name='thread_heaps_' type-id='type-id-1484' mangled-name='_ZN8tcmalloc11ThreadCache13thread_heaps_E' visibility='default' filepath='src/thread_cache.h' line='284' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache13thread_heaps_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static int tcmalloc::ThreadCache::thread_heap_count_ -->
          <var-decl name='thread_heap_count_' type-id='type-id-1' mangled-name='_ZN8tcmalloc11ThreadCache18thread_heap_count_E' visibility='default' filepath='src/thread_cache.h' line='285' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache18thread_heap_count_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::ThreadCache* tcmalloc::ThreadCache::next_memory_steal_ -->
          <var-decl name='next_memory_steal_' type-id='type-id-1484' mangled-name='_ZN8tcmalloc11ThreadCache18next_memory_steal_E' visibility='default' filepath='src/thread_cache.h' line='291' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache18next_memory_steal_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static size_t tcmalloc::ThreadCache::overall_thread_cache_size_ -->
          <var-decl name='overall_thread_cache_size_' type-id='type-id-57' mangled-name='_ZN8tcmalloc11ThreadCache26overall_thread_cache_size_E' visibility='default' filepath='src/thread_cache.h' line='294' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache26overall_thread_cache_size_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static volatile size_t tcmalloc::ThreadCache::per_thread_cache_size_ -->
          <var-decl name='per_thread_cache_size_' type-id='type-id-1495' mangled-name='_ZN8tcmalloc11ThreadCache22per_thread_cache_size_E' visibility='default' filepath='src/thread_cache.h' line='300' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache22per_thread_cache_size_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static ssize_t tcmalloc::ThreadCache::unclaimed_cache_space_ -->
          <var-decl name='unclaimed_cache_space_' type-id='type-id-274' mangled-name='_ZN8tcmalloc11ThreadCache22unclaimed_cache_space_E' visibility='default' filepath='src/thread_cache.h' line='304' column='1' elf-symbol-id='_ZN8tcmalloc11ThreadCache22unclaimed_cache_space_E'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- size_t tcmalloc::ThreadCache::size_ -->
          <var-decl name='size_' type-id='type-id-57' visibility='default' filepath='src/thread_cache.h' line='309' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- size_t tcmalloc::ThreadCache::max_size_ -->
          <var-decl name='max_size_' type-id='type-id-57' visibility='default' filepath='src/thread_cache.h' line='310' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='256'>
          <!-- tcmalloc::Sampler tcmalloc::ThreadCache::sampler_ -->
          <var-decl name='sampler_' type-id='type-id-1479' visibility='default' filepath='src/thread_cache.h' line='313' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='384'>
          <!-- tcmalloc::ThreadCache::FreeList tcmalloc::ThreadCache::list_[88] -->
          <var-decl name='list_' type-id='type-id-1358' visibility='default' filepath='src/thread_cache.h' line='315' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='17280'>
          <!-- pthread_t tcmalloc::ThreadCache::tid_ -->
          <var-decl name='tid_' type-id='type-id-199' visibility='default' filepath='src/thread_cache.h' line='317' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='17344'>
          <!-- bool tcmalloc::ThreadCache::in_setspecific_ -->
          <var-decl name='in_setspecific_' type-id='type-id-55' visibility='default' filepath='src/thread_cache.h' line='318' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::Init(pthread_t) -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc11ThreadCache4InitEm' filepath='src/thread_cache.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache4InitEm'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'typedef pthread_t' -->
            <parameter type-id='type-id-199'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::Cleanup() -->
          <function-decl name='Cleanup' mangled-name='_ZN8tcmalloc11ThreadCache7CleanupEv' filepath='src/thread_cache.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache7CleanupEv'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::ThreadCache::freelist_length(size_t) -->
          <function-decl name='freelist_length' mangled-name='_ZNK8tcmalloc11ThreadCache15freelist_lengthEm' filepath='src/thread_cache.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1451' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::ThreadCache::Size() -->
          <function-decl name='Size' mangled-name='_ZNK8tcmalloc11ThreadCache4SizeEv' filepath='src/thread_cache.h' line='85' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1451' is-artificial='yes'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* tcmalloc::ThreadCache::Allocate(size_t, size_t) -->
          <function-decl name='Allocate' mangled-name='_ZN8tcmalloc11ThreadCache8AllocateEmm' filepath='src/thread_cache.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void* -->
            <return type-id='type-id-53'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::Deallocate(void*, size_t) -->
          <function-decl name='Deallocate' mangled-name='_ZN8tcmalloc11ThreadCache10DeallocateEPvm' filepath='src/thread_cache.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::Scavenge() -->
          <function-decl name='Scavenge' mangled-name='_ZN8tcmalloc11ThreadCache8ScavengeEv' filepath='src/thread_cache.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache8ScavengeEv'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::ThreadCache::GetSamplePeriod() -->
          <function-decl name='GetSamplePeriod' mangled-name='_ZN8tcmalloc11ThreadCache15GetSamplePeriodEv' filepath='src/thread_cache.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache15GetSamplePeriodEv'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::ThreadCache::SampleAllocation(size_t) -->
          <function-decl name='SampleAllocation' mangled-name='_ZN8tcmalloc11ThreadCache16SampleAllocationEm' filepath='src/thread_cache.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::InitModule() -->
          <function-decl name='InitModule' mangled-name='_ZN8tcmalloc11ThreadCache10InitModuleEv' filepath='src/thread_cache.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache10InitModuleEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::InitTSD() -->
          <function-decl name='InitTSD' mangled-name='_ZN8tcmalloc11ThreadCache7InitTSDEv' filepath='src/thread_cache.h' line='101' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache7InitTSDEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::GetThreadHeap() -->
          <function-decl name='GetThreadHeap' mangled-name='_ZN8tcmalloc11ThreadCache13GetThreadHeapEv' filepath='src/thread_cache.h' line='102' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::GetCache() -->
          <function-decl name='GetCache' mangled-name='_ZN8tcmalloc11ThreadCache8GetCacheEv' filepath='src/thread_cache.h' line='103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache8GetCacheEv'>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::GetCacheIfPresent() -->
          <function-decl name='GetCacheIfPresent' mangled-name='_ZN8tcmalloc11ThreadCache17GetCacheIfPresentEv' filepath='src/thread_cache.h' line='104' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::GetCacheWhichMustBePresent() -->
          <function-decl name='GetCacheWhichMustBePresent' mangled-name='_ZN8tcmalloc11ThreadCache26GetCacheWhichMustBePresentEv' filepath='src/thread_cache.h' line='105' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::CreateCacheIfNecessary() -->
          <function-decl name='CreateCacheIfNecessary' mangled-name='_ZN8tcmalloc11ThreadCache22CreateCacheIfNecessaryEv' filepath='src/thread_cache.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache22CreateCacheIfNecessaryEv'>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::BecomeIdle() -->
          <function-decl name='BecomeIdle' mangled-name='_ZN8tcmalloc11ThreadCache10BecomeIdleEv' filepath='src/thread_cache.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache10BecomeIdleEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- size_t tcmalloc::ThreadCache::MinSizeForSlowPath() -->
          <function-decl name='MinSizeForSlowPath' mangled-name='_ZN8tcmalloc11ThreadCache18MinSizeForSlowPathEv' filepath='src/thread_cache.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::SetMinSizeForSlowPath() -->
          <function-decl name='SetMinSizeForSlowPath' mangled-name='_ZN8tcmalloc11ThreadCache21SetMinSizeForSlowPathEm' filepath='src/thread_cache.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- bool tcmalloc::ThreadCache::IsFastPathAllowed() -->
          <function-decl name='IsFastPathAllowed' mangled-name='_ZN8tcmalloc11ThreadCache17IsFastPathAllowedEv' filepath='src/thread_cache.h' line='111' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- int tcmalloc::ThreadCache::HeapsInUse() -->
          <function-decl name='HeapsInUse' mangled-name='_ZN8tcmalloc11ThreadCache10HeapsInUseEv' filepath='src/thread_cache.h' line='114' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::GetThreadStats(uint64_t*) -->
          <function-decl name='GetThreadStats' mangled-name='_ZN8tcmalloc11ThreadCache14GetThreadStatsEPmS1_' filepath='src/thread_cache.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache14GetThreadStatsEPmS1_'>
            <!-- parameter of type 'uint64_t*' -->
            <parameter type-id='type-id-1486'/>
            <!-- parameter of type 'uint64_t*' -->
            <parameter type-id='type-id-1486'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::set_overall_thread_cache_size() -->
          <function-decl name='set_overall_thread_cache_size' mangled-name='_ZN8tcmalloc11ThreadCache29set_overall_thread_cache_sizeEm' filepath='src/thread_cache.h' line='126' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache29set_overall_thread_cache_sizeEm'>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- size_t tcmalloc::ThreadCache::overall_thread_cache_size() -->
          <function-decl name='overall_thread_cache_size' mangled-name='_ZN8tcmalloc11ThreadCache25overall_thread_cache_sizeEv' filepath='src/thread_cache.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void* tcmalloc::ThreadCache::FetchFromCentralCache(size_t, size_t) -->
          <function-decl name='FetchFromCentralCache' mangled-name='_ZN8tcmalloc11ThreadCache21FetchFromCentralCacheEmm' filepath='src/thread_cache.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache21FetchFromCentralCacheEmm'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void* -->
            <return type-id='type-id-53'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::ListTooLong(tcmalloc::ThreadCache::FreeList*, size_t) -->
          <function-decl name='ListTooLong' mangled-name='_ZN8tcmalloc11ThreadCache11ListTooLongEPNS0_8FreeListEm' filepath='src/thread_cache.h' line='231' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache11ListTooLongEPNS0_8FreeListEm'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
            <parameter type-id='type-id-1485'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::ReleaseToCentralCache(tcmalloc::ThreadCache::FreeList*, size_t, int) -->
          <function-decl name='ReleaseToCentralCache' mangled-name='_ZN8tcmalloc11ThreadCache21ReleaseToCentralCacheEPNS0_8FreeListEmi' filepath='src/thread_cache.h' line='234' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache21ReleaseToCentralCacheEPNS0_8FreeListEmi'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::ThreadCache::FreeList*' -->
            <parameter type-id='type-id-1485'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::IncreaseCacheLimit() -->
          <function-decl name='IncreaseCacheLimit' mangled-name='_ZN8tcmalloc11ThreadCache18IncreaseCacheLimitEv' filepath='src/thread_cache.h' line='239' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache18IncreaseCacheLimitEv'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::IncreaseCacheLimitLocked() -->
          <function-decl name='IncreaseCacheLimitLocked' mangled-name='_ZN8tcmalloc11ThreadCache24IncreaseCacheLimitLockedEv' filepath='src/thread_cache.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache24IncreaseCacheLimitLockedEv'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::ThreadCache* tcmalloc::ThreadCache::NewHeap() -->
          <function-decl name='NewHeap' mangled-name='_ZN8tcmalloc11ThreadCache7NewHeapEm' filepath='src/thread_cache.h' line='321' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache7NewHeapEm'>
            <!-- parameter of type 'typedef pthread_t' -->
            <parameter type-id='type-id-199'/>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::DestroyThreadCache() -->
          <function-decl name='DestroyThreadCache' mangled-name='_ZN8tcmalloc11ThreadCache18DestroyThreadCacheEPv' filepath='src/thread_cache.h' line='324' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache18DestroyThreadCacheEPv'>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::ThreadCache::DeleteCache() -->
          <function-decl name='DeleteCache' mangled-name='_ZN8tcmalloc11ThreadCache11DeleteCacheEPS0_' filepath='src/thread_cache.h' line='326' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache11DeleteCacheEPS0_'>
            <!-- implicit parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::ThreadCache::RecomputePerThreadCacheSize() -->
          <function-decl name='RecomputePerThreadCacheSize' mangled-name='_ZN8tcmalloc11ThreadCache27RecomputePerThreadCacheSizeEv' filepath='src/thread_cache.h' line='327' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc11ThreadCache27RecomputePerThreadCacheSizeEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::Static -->
      <class-decl name='Static' size-in-bits='8' visibility='default' filepath='src/static_vars.h' line='50' column='1' id='type-id-1509'>
        <data-member access='private' static='yes'>
          <!-- static SpinLock tcmalloc::Static::pageheap_lock_ -->
          <var-decl name='pageheap_lock_' type-id='type-id-82' mangled-name='_ZN8tcmalloc6Static14pageheap_lock_E' visibility='default' filepath='src/static_vars.h' line='90' column='1' elf-symbol-id='_ZN8tcmalloc6Static14pageheap_lock_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::SizeMap tcmalloc::Static::sizemap_ -->
          <var-decl name='sizemap_' type-id='type-id-1481' mangled-name='_ZN8tcmalloc6Static8sizemap_E' visibility='default' filepath='src/static_vars.h' line='97' column='1' elf-symbol-id='_ZN8tcmalloc6Static8sizemap_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::CentralFreeListPadded tcmalloc::Static::central_cache_[88] -->
          <var-decl name='central_cache_' type-id='type-id-1354' mangled-name='_ZN8tcmalloc6Static14central_cache_E' visibility='default' filepath='src/static_vars.h' line='98' column='1' elf-symbol-id='_ZN8tcmalloc6Static14central_cache_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::PageHeapAllocator<tcmalloc::Span> tcmalloc::Static::span_allocator_ -->
          <var-decl name='span_allocator_' type-id='type-id-1440' mangled-name='_ZN8tcmalloc6Static15span_allocator_E' visibility='default' filepath='src/static_vars.h' line='99' column='1' elf-symbol-id='_ZN8tcmalloc6Static15span_allocator_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::PageHeapAllocator<tcmalloc::StackTrace> tcmalloc::Static::stacktrace_allocator_ -->
          <var-decl name='stacktrace_allocator_' type-id='type-id-1443' mangled-name='_ZN8tcmalloc6Static21stacktrace_allocator_E' visibility='default' filepath='src/static_vars.h' line='100' column='1' elf-symbol-id='_ZN8tcmalloc6Static21stacktrace_allocator_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::Span tcmalloc::Static::sampled_objects_ -->
          <var-decl name='sampled_objects_' type-id='type-id-138' mangled-name='_ZN8tcmalloc6Static16sampled_objects_E' visibility='default' filepath='src/static_vars.h' line='101' column='1' elf-symbol-id='_ZN8tcmalloc6Static16sampled_objects_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket> tcmalloc::Static::bucket_allocator_ -->
          <var-decl name='bucket_allocator_' type-id='type-id-1231' mangled-name='_ZN8tcmalloc6Static17bucket_allocator_E' visibility='default' filepath='src/static_vars.h' line='102' column='1' elf-symbol-id='_ZN8tcmalloc6Static17bucket_allocator_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::StackTrace* tcmalloc::Static::growth_stacks_ -->
          <var-decl name='growth_stacks_' type-id='type-id-1483' mangled-name='_ZN8tcmalloc6Static14growth_stacks_E' visibility='default' filepath='src/static_vars.h' line='108' column='1' elf-symbol-id='_ZN8tcmalloc6Static14growth_stacks_E'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static tcmalloc::PageHeap* tcmalloc::Static::pageheap_ -->
          <var-decl name='pageheap_' type-id='type-id-1469' mangled-name='_ZN8tcmalloc6Static9pageheap_E' visibility='default' filepath='src/static_vars.h' line='110' column='1' elf-symbol-id='_ZN8tcmalloc6Static9pageheap_E'/>
        </data-member>
        <member-function access='private' static='yes'>
          <!-- SpinLock* tcmalloc::Static::pageheap_lock() -->
          <function-decl name='pageheap_lock' mangled-name='_ZN8tcmalloc6Static13pageheap_lockEv' filepath='src/static_vars.h' line='53' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- SpinLock* -->
            <return type-id='type-id-89'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::Static::InitStaticVars() -->
          <function-decl name='InitStaticVars' mangled-name='_ZN8tcmalloc6Static14InitStaticVarsEv' filepath='src/static_vars.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc6Static14InitStaticVarsEv'>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::CentralFreeListPadded* tcmalloc::Static::central_cache() -->
          <function-decl name='central_cache' mangled-name='_ZN8tcmalloc6Static13central_cacheEv' filepath='src/static_vars.h' line='60' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::CentralFreeListPadded* -->
            <return type-id='type-id-1468'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::SizeMap* tcmalloc::Static::sizemap() -->
          <function-decl name='sizemap' mangled-name='_ZN8tcmalloc6Static7sizemapEv' filepath='src/static_vars.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::SizeMap* -->
            <return type-id='type-id-1482'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::PageHeap* tcmalloc::Static::pageheap() -->
          <function-decl name='pageheap' mangled-name='_ZN8tcmalloc6Static8pageheapEv' filepath='src/static_vars.h' line='69' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::PageHeap* -->
            <return type-id='type-id-1469'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::PageHeapAllocator<tcmalloc::Span>* tcmalloc::Static::span_allocator() -->
          <function-decl name='span_allocator' mangled-name='_ZN8tcmalloc6Static14span_allocatorEv' filepath='src/static_vars.h' line='71' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::PageHeapAllocator<tcmalloc::Span>* -->
            <return type-id='type-id-1476'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>* tcmalloc::Static::stacktrace_allocator() -->
          <function-decl name='stacktrace_allocator' mangled-name='_ZN8tcmalloc6Static20stacktrace_allocatorEv' filepath='src/static_vars.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>* -->
            <return type-id='type-id-1477'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::StackTrace* tcmalloc::Static::growth_stacks() -->
          <function-decl name='growth_stacks' mangled-name='_ZN8tcmalloc6Static13growth_stacksEv' filepath='src/static_vars.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::StackTrace* -->
            <return type-id='type-id-1483'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- void tcmalloc::Static::set_growth_stacks() -->
          <function-decl name='set_growth_stacks' mangled-name='_ZN8tcmalloc6Static17set_growth_stacksEPNS_10StackTraceE' filepath='src/static_vars.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'tcmalloc::StackTrace*' -->
            <parameter type-id='type-id-1483'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::Span* tcmalloc::Static::sampled_objects() -->
          <function-decl name='sampled_objects' mangled-name='_ZN8tcmalloc6Static15sampled_objectsEv' filepath='src/static_vars.h' line='81' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>* tcmalloc::Static::bucket_allocator() -->
          <function-decl name='bucket_allocator' mangled-name='_ZN8tcmalloc6Static16bucket_allocatorEv' filepath='src/static_vars.h' line='82' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>* -->
            <return type-id='type-id-1246'/>
          </function-decl>
        </member-function>
        <member-function access='private' static='yes'>
          <!-- bool tcmalloc::Static::IsInited() -->
          <function-decl name='IsInited' mangled-name='_ZN8tcmalloc6Static8IsInitedEv' filepath='src/static_vars.h' line='87' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::PageHeapAllocator<tcmalloc::Span> -->
      <class-decl name='PageHeapAllocator&lt;tcmalloc::Span&gt;' size-in-bits='256' visibility='default' filepath='src/page_heap_allocator.h' line='47' column='1' id='type-id-1440'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeapAllocator<tcmalloc::Span>::kAllocIncrement -->
          <var-decl name='kAllocIncrement' type-id='type-id-134' visibility='default' filepath='src/page_heap_allocator.h' line='99' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::PageHeapAllocator<tcmalloc::Span>::free_area_ -->
          <var-decl name='free_area_' type-id='type-id-113' visibility='default' filepath='src/page_heap_allocator.h' line='102' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::PageHeapAllocator<tcmalloc::Span>::free_avail_ -->
          <var-decl name='free_avail_' type-id='type-id-57' visibility='default' filepath='src/page_heap_allocator.h' line='103' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::PageHeapAllocator<tcmalloc::Span>::free_list_ -->
          <var-decl name='free_list_' type-id='type-id-53' visibility='default' filepath='src/page_heap_allocator.h' line='106' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::Span>::inuse_ -->
          <var-decl name='inuse_' type-id='type-id-1' visibility='default' filepath='src/page_heap_allocator.h' line='109' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::Span>::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_4SpanEE4InitEv' filepath='src/page_heap_allocator.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::Span>*' -->
            <parameter type-id='type-id-1476' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeapAllocator<tcmalloc::Span>::New() -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_4SpanEE3NewEv' filepath='src/page_heap_allocator.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::Span>*' -->
            <parameter type-id='type-id-1476' is-artificial='yes'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::Span>::Delete(tcmalloc::Span*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_4SpanEE6DeleteEPS1_' filepath='src/page_heap_allocator.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::Span>*' -->
            <parameter type-id='type-id-1476' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::Span>::inuse() -->
          <function-decl name='inuse' mangled-name='_ZNK8tcmalloc17PageHeapAllocatorINS_4SpanEE5inuseEv' filepath='src/page_heap_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeapAllocator<tcmalloc::Span>*' -->
            <parameter type-id='type-id-1442' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::PageHeapAllocator<tcmalloc::StackTrace> -->
      <class-decl name='PageHeapAllocator&lt;tcmalloc::StackTrace&gt;' size-in-bits='256' visibility='default' filepath='src/page_heap_allocator.h' line='47' column='1' id='type-id-1443'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::kAllocIncrement -->
          <var-decl name='kAllocIncrement' type-id='type-id-134' visibility='default' filepath='src/page_heap_allocator.h' line='99' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::free_area_ -->
          <var-decl name='free_area_' type-id='type-id-113' visibility='default' filepath='src/page_heap_allocator.h' line='102' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::free_avail_ -->
          <var-decl name='free_avail_' type-id='type-id-57' visibility='default' filepath='src/page_heap_allocator.h' line='103' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::free_list_ -->
          <var-decl name='free_list_' type-id='type-id-53' visibility='default' filepath='src/page_heap_allocator.h' line='106' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::inuse_ -->
          <var-decl name='inuse_' type-id='type-id-1' visibility='default' filepath='src/page_heap_allocator.h' line='109' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_10StackTraceEE4InitEv' filepath='src/page_heap_allocator.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>*' -->
            <parameter type-id='type-id-1477' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::StackTrace* tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::New() -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_10StackTraceEE3NewEv' filepath='src/page_heap_allocator.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>*' -->
            <parameter type-id='type-id-1477' is-artificial='yes'/>
            <!-- tcmalloc::StackTrace* -->
            <return type-id='type-id-1483'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::Delete(tcmalloc::StackTrace*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_10StackTraceEE6DeleteEPS1_' filepath='src/page_heap_allocator.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>*' -->
            <parameter type-id='type-id-1477' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::StackTrace*' -->
            <parameter type-id='type-id-1483'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>::inuse() -->
          <function-decl name='inuse' mangled-name='_ZNK8tcmalloc17PageHeapAllocatorINS_10StackTraceEE5inuseEv' filepath='src/page_heap_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeapAllocator<tcmalloc::StackTrace>*' -->
            <parameter type-id='type-id-1445' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::LogItem -->
      <class-decl name='LogItem' size-in-bits='128' visibility='default' filepath='src/internal_logging.h' line='70' column='1' id='type-id-1019'>
        <member-type access='private'>
          <!-- enum tcmalloc::LogItem::Tag -->
          <enum-decl name='Tag' filepath='src/internal_logging.h' line='83' column='1' id='type-id-1026'>
            <underlying-type type-id='type-id-84'/>
            <enumerator name='kStr' value='0'/>
            <enumerator name='kSigned' value='1'/>
            <enumerator name='kUnsigned' value='2'/>
            <enumerator name='kPtr' value='3'/>
            <enumerator name='kEnd' value='4'/>
          </enum-decl>
        </member-type>
        <member-type access='private'>
          <!-- union {const char* str; void* ptr; int64_t snum; uint64_t unum;} -->
          <union-decl name='__anonymous_union__' size-in-bits='64' is-anonymous='yes' visibility='default' filepath='src/internal_logging.h' line='91' column='1' id='type-id-1027'>
            <data-member access='private'>
              <!-- const char* str -->
              <var-decl name='str' type-id='type-id-52' visibility='default' filepath='src/internal_logging.h' line='92' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- void* ptr -->
              <var-decl name='ptr' type-id='type-id-53' visibility='default' filepath='src/internal_logging.h' line='93' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- int64_t snum -->
              <var-decl name='snum' type-id='type-id-98' visibility='default' filepath='src/internal_logging.h' line='94' column='1'/>
            </data-member>
            <data-member access='private'>
              <!-- uint64_t unum -->
              <var-decl name='unum' type-id='type-id-15' visibility='default' filepath='src/internal_logging.h' line='95' column='1'/>
            </data-member>
          </union-decl>
        </member-type>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- tcmalloc::LogItem::Tag tcmalloc::LogItem::tag_ -->
          <var-decl name='tag_' type-id='type-id-1026' visibility='default' filepath='src/internal_logging.h' line='90' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- union {const char* str; void* ptr; int64_t snum; uint64_t unum;} tcmalloc::LogItem::u_ -->
          <var-decl name='u_' type-id='type-id-1027' visibility='default' filepath='src/internal_logging.h' line='96' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem() -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='72' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(const char*) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'const char*' -->
            <parameter type-id='type-id-52'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long int' -->
            <parameter type-id='type-id-80'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long long int' -->
            <parameter type-id='type-id-1029'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(unsigned int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'unsigned int' -->
            <parameter type-id='type-id-59'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(unsigned long int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='78' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'unsigned long int' -->
            <parameter type-id='type-id-5'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(long long unsigned int) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'long long unsigned int' -->
            <parameter type-id='type-id-1030'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::LogItem::LogItem(void*) -->
          <function-decl name='LogItem' filepath='src/internal_logging.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::LogItem*' -->
            <parameter type-id='type-id-1028' is-artificial='yes'/>
            <!-- parameter of type 'void*' -->
            <parameter type-id='type-id-53'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket> -->
      <class-decl name='PageHeapAllocator&lt;tcmalloc::StackTraceTable::Bucket&gt;' size-in-bits='256' visibility='default' filepath='src/page_heap_allocator.h' line='47' column='1' id='type-id-1231'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::kAllocIncrement -->
          <var-decl name='kAllocIncrement' type-id='type-id-134' visibility='default' filepath='src/page_heap_allocator.h' line='99' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_area_ -->
          <var-decl name='free_area_' type-id='type-id-113' visibility='default' filepath='src/page_heap_allocator.h' line='102' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_avail_ -->
          <var-decl name='free_avail_' type-id='type-id-57' visibility='default' filepath='src/page_heap_allocator.h' line='103' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::free_list_ -->
          <var-decl name='free_list_' type-id='type-id-53' visibility='default' filepath='src/page_heap_allocator.h' line='106' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::inuse_ -->
          <var-decl name='inuse_' type-id='type-id-1' visibility='default' filepath='src/page_heap_allocator.h' line='109' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE4InitEv' filepath='src/page_heap_allocator.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::StackTraceTable::Bucket* tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::New() -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE3NewEv' filepath='src/page_heap_allocator.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- tcmalloc::StackTraceTable::Bucket* -->
            <return type-id='type-id-1244'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::Delete(tcmalloc::StackTraceTable::Bucket*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE6DeleteEPS2_' filepath='src/page_heap_allocator.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1246' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::StackTraceTable::Bucket*' -->
            <parameter type-id='type-id-1244'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>::inuse() -->
          <function-decl name='inuse' mangled-name='_ZNK8tcmalloc17PageHeapAllocatorINS_15StackTraceTable6BucketEE5inuseEv' filepath='src/page_heap_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeapAllocator<tcmalloc::StackTraceTable::Bucket>*' -->
            <parameter type-id='type-id-1233' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache> -->
      <class-decl name='PageHeapAllocator&lt;tcmalloc::ThreadCache&gt;' size-in-bits='256' visibility='default' filepath='src/page_heap_allocator.h' line='47' column='1' id='type-id-1446'>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::kAllocIncrement -->
          <var-decl name='kAllocIncrement' type-id='type-id-134' visibility='default' filepath='src/page_heap_allocator.h' line='99' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- char* tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::free_area_ -->
          <var-decl name='free_area_' type-id='type-id-113' visibility='default' filepath='src/page_heap_allocator.h' line='102' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='64'>
          <!-- size_t tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::free_avail_ -->
          <var-decl name='free_avail_' type-id='type-id-57' visibility='default' filepath='src/page_heap_allocator.h' line='103' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::free_list_ -->
          <var-decl name='free_list_' type-id='type-id-53' visibility='default' filepath='src/page_heap_allocator.h' line='106' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='192'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::inuse_ -->
          <var-decl name='inuse_' type-id='type-id-1' visibility='default' filepath='src/page_heap_allocator.h' line='109' column='1'/>
        </data-member>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_11ThreadCacheEE4InitEv' filepath='src/page_heap_allocator.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>*' -->
            <parameter type-id='type-id-1478' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::ThreadCache* tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::New() -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_11ThreadCacheEE3NewEv' filepath='src/page_heap_allocator.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>*' -->
            <parameter type-id='type-id-1478' is-artificial='yes'/>
            <!-- tcmalloc::ThreadCache* -->
            <return type-id='type-id-1484'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::Delete(tcmalloc::ThreadCache*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc17PageHeapAllocatorINS_11ThreadCacheEE6DeleteEPS1_' filepath='src/page_heap_allocator.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>*' -->
            <parameter type-id='type-id-1478' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::ThreadCache*' -->
            <parameter type-id='type-id-1484'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>::inuse() -->
          <function-decl name='inuse' mangled-name='_ZNK8tcmalloc17PageHeapAllocatorINS_11ThreadCacheEE5inuseEv' filepath='src/page_heap_allocator.h' line='95' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache>*' -->
            <parameter type-id='type-id-1448' is-artificial='yes'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::PageHeap -->
      <class-decl name='PageHeap' size-in-bits='4293888' visibility='default' filepath='src/page_heap.h' line='104' column='1' id='type-id-1437'>
        <member-type access='private'>
          <!-- struct tcmalloc::PageHeap::Stats -->
          <class-decl name='Stats' size-in-bits='256' is-struct='yes' visibility='default' filepath='src/page_heap.h' line='145' column='1' id='type-id-1410'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- uint64_t tcmalloc::PageHeap::Stats::system_bytes -->
              <var-decl name='system_bytes' type-id='type-id-15' visibility='default' filepath='src/page_heap.h' line='147' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- uint64_t tcmalloc::PageHeap::Stats::free_bytes -->
              <var-decl name='free_bytes' type-id='type-id-15' visibility='default' filepath='src/page_heap.h' line='148' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- uint64_t tcmalloc::PageHeap::Stats::unmapped_bytes -->
              <var-decl name='unmapped_bytes' type-id='type-id-15' visibility='default' filepath='src/page_heap.h' line='149' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='192'>
              <!-- uint64_t tcmalloc::PageHeap::Stats::committed_bytes -->
              <var-decl name='committed_bytes' type-id='type-id-15' visibility='default' filepath='src/page_heap.h' line='150' column='1'/>
            </data-member>
            <member-function access='public' constructor='yes'>
              <!-- tcmalloc::PageHeap::Stats::Stats() -->
              <function-decl name='Stats' filepath='src/page_heap.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
                <!-- implicit parameter of type 'tcmalloc::PageHeap::Stats*' -->
                <parameter type-id='type-id-1475' is-artificial='yes'/>
                <!-- void -->
                <return type-id='type-id-56'/>
              </function-decl>
            </member-function>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct tcmalloc::PageHeap::SmallSpanStats -->
          <class-decl name='SmallSpanStats' size-in-bits='16384' is-struct='yes' visibility='default' filepath='src/page_heap.h' line='155' column='1' id='type-id-1472'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- int64 tcmalloc::PageHeap::SmallSpanStats::normal_length[128] -->
              <var-decl name='normal_length' type-id='type-id-1344' visibility='default' filepath='src/page_heap.h' line='158' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='8192'>
              <!-- int64 tcmalloc::PageHeap::SmallSpanStats::returned_length[128] -->
              <var-decl name='returned_length' type-id='type-id-1344' visibility='default' filepath='src/page_heap.h' line='159' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct tcmalloc::PageHeap::LargeSpanStats -->
          <class-decl name='LargeSpanStats' size-in-bits='192' is-struct='yes' visibility='default' filepath='src/page_heap.h' line='164' column='1' id='type-id-1470'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- int64 tcmalloc::PageHeap::LargeSpanStats::spans -->
              <var-decl name='spans' type-id='type-id-93' visibility='default' filepath='src/page_heap.h' line='165' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='64'>
              <!-- int64 tcmalloc::PageHeap::LargeSpanStats::normal_pages -->
              <var-decl name='normal_pages' type-id='type-id-93' visibility='default' filepath='src/page_heap.h' line='166' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='128'>
              <!-- int64 tcmalloc::PageHeap::LargeSpanStats::returned_pages -->
              <var-decl name='returned_pages' type-id='type-id-93' visibility='default' filepath='src/page_heap.h' line='167' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- struct tcmalloc::PageHeap::SpanList -->
          <class-decl name='SpanList' size-in-bits='768' is-struct='yes' visibility='default' filepath='src/page_heap.h' line='232' column='1' id='type-id-1355'>
            <data-member access='public' layout-offset-in-bits='0'>
              <!-- tcmalloc::Span tcmalloc::PageHeap::SpanList::normal -->
              <var-decl name='normal' type-id='type-id-138' visibility='default' filepath='src/page_heap.h' line='233' column='1'/>
            </data-member>
            <data-member access='public' layout-offset-in-bits='384'>
              <!-- tcmalloc::Span tcmalloc::PageHeap::SpanList::returned -->
              <var-decl name='returned' type-id='type-id-138' visibility='default' filepath='src/page_heap.h' line='234' column='1'/>
            </data-member>
          </class-decl>
        </member-type>
        <member-type access='private'>
          <!-- typedef TCMalloc_PageMap3<35> tcmalloc::PageHeap::PageMap -->
          <typedef-decl name='PageMap' type-id='type-id-1368' filepath='src/page_heap.h' line='224' column='1' id='type-id-1510'/>
        </member-type>
        <member-type access='private'>
          <!-- typedef PackedCache<35, long unsigned int> tcmalloc::PageHeap::PageMapCache -->
          <typedef-decl name='PageMapCache' type-id='type-id-1381' filepath='src/page_heap.h' line='225' column='1' id='type-id-1511'/>
        </member-type>
        <data-member access='private' static='yes'>
          <!-- static const size_t tcmalloc::PageHeap::kPageMapBigAllocationThreshold -->
          <var-decl name='kPageMapBigAllocationThreshold' type-id='type-id-112' visibility='default' filepath='src/page_heap.h' line='203' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeap::kMinSystemAlloc -->
          <var-decl name='kMinSystemAlloc' type-id='type-id-134' visibility='default' filepath='src/page_heap.h' line='212' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeap::kMaxReleaseDelay -->
          <var-decl name='kMaxReleaseDelay' type-id='type-id-134' visibility='default' filepath='src/page_heap.h' line='217' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::PageHeap::kDefaultReleaseDelay -->
          <var-decl name='kDefaultReleaseDelay' type-id='type-id-134' visibility='default' filepath='src/page_heap.h' line='221' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- tcmalloc::PageHeap::PageMap tcmalloc::PageHeap::pagemap_ -->
          <var-decl name='pagemap_' type-id='type-id-1510' visibility='default' filepath='src/page_heap.h' line='226' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='128'>
          <!-- tcmalloc::PageHeap::PageMapCache tcmalloc::PageHeap::pagemap_cache_ -->
          <var-decl name='pagemap_cache_' type-id='type-id-1511' visibility='default' filepath='src/page_heap.h' line='227' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4194432'>
          <!-- tcmalloc::PageHeap::SpanList tcmalloc::PageHeap::large_ -->
          <var-decl name='large_' type-id='type-id-1355' visibility='default' filepath='src/page_heap.h' line='238' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4195200'>
          <!-- tcmalloc::PageHeap::SpanList tcmalloc::PageHeap::free_[128] -->
          <var-decl name='free_' type-id='type-id-1356' visibility='default' filepath='src/page_heap.h' line='241' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4293504'>
          <!-- tcmalloc::PageHeap::Stats tcmalloc::PageHeap::stats_ -->
          <var-decl name='stats_' type-id='type-id-1410' visibility='default' filepath='src/page_heap.h' line='244' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4293760'>
          <!-- int64_t tcmalloc::PageHeap::scavenge_counter_ -->
          <var-decl name='scavenge_counter_' type-id='type-id-98' visibility='default' filepath='src/page_heap.h' line='302' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4293824'>
          <!-- int tcmalloc::PageHeap::release_index_ -->
          <var-decl name='release_index_' type-id='type-id-1' visibility='default' filepath='src/page_heap.h' line='305' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='4293856'>
          <!-- bool tcmalloc::PageHeap::aggressive_decommit_ -->
          <var-decl name='aggressive_decommit_' type-id='type-id-55' visibility='default' filepath='src/page_heap.h' line='307' column='1'/>
        </data-member>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::PageHeap::PageHeap() -->
          <function-decl name='PageHeap' mangled-name='_ZN8tcmalloc8PageHeapC1Ev' filepath='src/page_heap.h' line='106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeapC1Ev'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::New(Length) -->
          <function-decl name='New' mangled-name='_ZN8tcmalloc8PageHeap3NewEm' filepath='src/page_heap.h' line='111' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap3NewEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::Delete(tcmalloc::Span*) -->
          <function-decl name='Delete' mangled-name='_ZN8tcmalloc8PageHeap6DeleteEPNS_4SpanE' filepath='src/page_heap.h' line='116' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap6DeleteEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::RegisterSizeClass(tcmalloc::Span*, size_t) -->
          <function-decl name='RegisterSizeClass' mangled-name='_ZN8tcmalloc8PageHeap17RegisterSizeClassEPNS_4SpanEm' filepath='src/page_heap.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap17RegisterSizeClassEPNS_4SpanEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::Split(tcmalloc::Span*, Length) -->
          <function-decl name='Split' mangled-name='_ZN8tcmalloc8PageHeap5SplitEPNS_4SpanEm' filepath='src/page_heap.h' line='132' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap5SplitEPNS_4SpanEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::GetDescriptor(PageID) -->
          <function-decl name='GetDescriptor' mangled-name='_ZNK8tcmalloc8PageHeap13GetDescriptorEm' filepath='src/page_heap.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1439' is-artificial='yes'/>
            <!-- parameter of type 'typedef PageID' -->
            <parameter type-id='type-id-142'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::GetNextRange(PageID, base::MallocRange*) -->
          <function-decl name='GetNextRange' mangled-name='_ZN8tcmalloc8PageHeap12GetNextRangeEmPN4base11MallocRangeE' filepath='src/page_heap.h' line='142' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap12GetNextRangeEmPN4base11MallocRangeE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef PageID' -->
            <parameter type-id='type-id-142'/>
            <!-- parameter of type 'base::MallocRange*' -->
            <parameter type-id='type-id-1420'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::PageHeap::Stats tcmalloc::PageHeap::stats() -->
          <function-decl name='stats' mangled-name='_ZNK8tcmalloc8PageHeap5statsEv' filepath='src/page_heap.h' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1439' is-artificial='yes'/>
            <!-- struct tcmalloc::PageHeap::Stats -->
            <return type-id='type-id-1410'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::GetSmallSpanStats(tcmalloc::PageHeap::SmallSpanStats*) -->
          <function-decl name='GetSmallSpanStats' mangled-name='_ZN8tcmalloc8PageHeap17GetSmallSpanStatsEPNS0_14SmallSpanStatsE' filepath='src/page_heap.h' line='161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap17GetSmallSpanStatsEPNS0_14SmallSpanStatsE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::PageHeap::SmallSpanStats*' -->
            <parameter type-id='type-id-1473'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::GetLargeSpanStats(tcmalloc::PageHeap::LargeSpanStats*) -->
          <function-decl name='GetLargeSpanStats' mangled-name='_ZN8tcmalloc8PageHeap17GetLargeSpanStatsEPNS0_14LargeSpanStatsE' filepath='src/page_heap.h' line='169' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap17GetLargeSpanStatsEPNS0_14LargeSpanStatsE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::PageHeap::LargeSpanStats*' -->
            <parameter type-id='type-id-1471'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::Check() -->
          <function-decl name='Check' mangled-name='_ZN8tcmalloc8PageHeap5CheckEv' filepath='src/page_heap.h' line='171' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap5CheckEv'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::CheckExpensive() -->
          <function-decl name='CheckExpensive' mangled-name='_ZN8tcmalloc8PageHeap14CheckExpensiveEv' filepath='src/page_heap.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap14CheckExpensiveEv'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::CheckList(tcmalloc::Span*, Length, Length, int) -->
          <function-decl name='CheckList' mangled-name='_ZN8tcmalloc8PageHeap9CheckListEPNS_4SpanEmmi' filepath='src/page_heap.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap9CheckListEPNS_4SpanEmmi'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- Length tcmalloc::PageHeap::ReleaseAtLeastNPages(Length) -->
          <function-decl name='ReleaseAtLeastNPages' mangled-name='_ZN8tcmalloc8PageHeap20ReleaseAtLeastNPagesEm' filepath='src/page_heap.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap20ReleaseAtLeastNPagesEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- typedef Length -->
            <return type-id='type-id-143'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::PageHeap::GetSizeClassIfCached(PageID) -->
          <function-decl name='GetSizeClassIfCached' mangled-name='_ZNK8tcmalloc8PageHeap20GetSizeClassIfCachedEm' filepath='src/page_heap.h' line='190' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1439' is-artificial='yes'/>
            <!-- parameter of type 'typedef PageID' -->
            <parameter type-id='type-id-142'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::CacheSizeClass(PageID, size_t) -->
          <function-decl name='CacheSizeClass' mangled-name='_ZNK8tcmalloc8PageHeap14CacheSizeClassEmm' filepath='src/page_heap.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'const tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1439' is-artificial='yes'/>
            <!-- parameter of type 'typedef PageID' -->
            <parameter type-id='type-id-142'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::GetAggressiveDecommit() -->
          <function-decl name='GetAggressiveDecommit' mangled-name='_ZN8tcmalloc8PageHeap21GetAggressiveDecommitEv' filepath='src/page_heap.h' line='195' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::SetAggressiveDecommit(bool) -->
          <function-decl name='SetAggressiveDecommit' mangled-name='_ZN8tcmalloc8PageHeap21SetAggressiveDecommitEb' filepath='src/page_heap.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'bool' -->
            <parameter type-id='type-id-55'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::SearchFreeAndLargeLists(Length) -->
          <function-decl name='SearchFreeAndLargeLists' mangled-name='_ZN8tcmalloc8PageHeap23SearchFreeAndLargeListsEm' filepath='src/page_heap.h' line='246' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap23SearchFreeAndLargeListsEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::GrowHeap(Length) -->
          <function-decl name='GrowHeap' mangled-name='_ZN8tcmalloc8PageHeap8GrowHeapEm' filepath='src/page_heap.h' line='248' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap8GrowHeapEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::Carve(tcmalloc::Span*, Length) -->
          <function-decl name='Carve' mangled-name='_ZN8tcmalloc8PageHeap5CarveEPNS_4SpanEm' filepath='src/page_heap.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap5CarveEPNS_4SpanEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::RecordSpan(tcmalloc::Span*) -->
          <function-decl name='RecordSpan' mangled-name='_ZN8tcmalloc8PageHeap10RecordSpanEPNS_4SpanE' filepath='src/page_heap.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- tcmalloc::Span* tcmalloc::PageHeap::AllocLarge(Length) -->
          <function-decl name='AllocLarge' mangled-name='_ZN8tcmalloc8PageHeap10AllocLargeEm' filepath='src/page_heap.h' line='268' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap10AllocLargeEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- tcmalloc::Span* -->
            <return type-id='type-id-144'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::MergeIntoFreeList(tcmalloc::Span*) -->
          <function-decl name='MergeIntoFreeList' mangled-name='_ZN8tcmalloc8PageHeap17MergeIntoFreeListEPNS_4SpanE' filepath='src/page_heap.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap17MergeIntoFreeListEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::CommitSpan(tcmalloc::Span*) -->
          <function-decl name='CommitSpan' mangled-name='_ZN8tcmalloc8PageHeap10CommitSpanEPNS_4SpanE' filepath='src/page_heap.h' line='275' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap10CommitSpanEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::DecommitSpan(tcmalloc::Span*) -->
          <function-decl name='DecommitSpan' mangled-name='_ZN8tcmalloc8PageHeap12DecommitSpanEPNS_4SpanE' filepath='src/page_heap.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap12DecommitSpanEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::PrependToFreeList(tcmalloc::Span*) -->
          <function-decl name='PrependToFreeList' mangled-name='_ZN8tcmalloc8PageHeap17PrependToFreeListEPNS_4SpanE' filepath='src/page_heap.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap17PrependToFreeListEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::RemoveFromFreeList(tcmalloc::Span*) -->
          <function-decl name='RemoveFromFreeList' mangled-name='_ZN8tcmalloc8PageHeap18RemoveFromFreeListEPNS_4SpanE' filepath='src/page_heap.h' line='284' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap18RemoveFromFreeListEPNS_4SpanE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::PageHeap::IncrementalScavenge(Length) -->
          <function-decl name='IncrementalScavenge' mangled-name='_ZN8tcmalloc8PageHeap19IncrementalScavengeEm' filepath='src/page_heap.h' line='288' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap19IncrementalScavengeEm'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- Length tcmalloc::PageHeap::ReleaseLastNormalSpan(tcmalloc::PageHeap::SpanList*) -->
          <function-decl name='ReleaseLastNormalSpan' mangled-name='_ZN8tcmalloc8PageHeap21ReleaseLastNormalSpanEPNS0_8SpanListE' filepath='src/page_heap.h' line='292' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap21ReleaseLastNormalSpanEPNS0_8SpanListE'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::PageHeap::SpanList*' -->
            <parameter type-id='type-id-1474'/>
            <!-- typedef Length -->
            <return type-id='type-id-143'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::EnsureLimit(Length, bool) -->
          <function-decl name='EnsureLimit' mangled-name='_ZN8tcmalloc8PageHeap11EnsureLimitEmb' filepath='src/page_heap.h' line='297' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap11EnsureLimitEmb'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'typedef Length' -->
            <parameter type-id='type-id-143'/>
            <!-- parameter of type 'bool' -->
            <parameter type-id='type-id-55'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- bool tcmalloc::PageHeap::MayMergeSpans(tcmalloc::Span*, tcmalloc::Span*) -->
          <function-decl name='MayMergeSpans' mangled-name='_ZN8tcmalloc8PageHeap13MayMergeSpansEPNS_4SpanES2_' filepath='src/page_heap.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc8PageHeap13MayMergeSpansEPNS_4SpanES2_'>
            <!-- implicit parameter of type 'tcmalloc::PageHeap*' -->
            <parameter type-id='type-id-1469' is-artificial='yes'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- parameter of type 'tcmalloc::Span*' -->
            <parameter type-id='type-id-144'/>
            <!-- bool -->
            <return type-id='type-id-55'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- class tcmalloc::SizeMap -->
      <class-decl name='SizeMap' size-in-bits='31488' visibility='default' filepath='src/common.h' line='161' column='1' id='type-id-1481'>
        <data-member access='private' layout-offset-in-bits='0'>
          <!-- int tcmalloc::SizeMap::num_objects_to_move_[88] -->
          <var-decl name='num_objects_to_move_' type-id='type-id-1346' visibility='default' filepath='src/common.h' line='168' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const int tcmalloc::SizeMap::kMaxSmallSize -->
          <var-decl name='kMaxSmallSize' type-id='type-id-134' visibility='default' filepath='src/common.h' line='192' column='1'/>
        </data-member>
        <data-member access='private' static='yes'>
          <!-- static const size_t tcmalloc::SizeMap::kClassArraySize -->
          <var-decl name='kClassArraySize' type-id='type-id-112' visibility='default' filepath='src/common.h' line='194' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='2816'>
          <!-- unsigned char tcmalloc::SizeMap::class_array_[2169] -->
          <var-decl name='class_array_' type-id='type-id-1359' visibility='default' filepath='src/common.h' line='195' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='20224'>
          <!-- size_t tcmalloc::SizeMap::class_to_size_[88] -->
          <var-decl name='class_to_size_' type-id='type-id-1350' visibility='default' filepath='src/common.h' line='212' column='1'/>
        </data-member>
        <data-member access='private' layout-offset-in-bits='25856'>
          <!-- size_t tcmalloc::SizeMap::class_to_pages_[88] -->
          <var-decl name='class_to_pages_' type-id='type-id-1350' visibility='default' filepath='src/common.h' line='215' column='1'/>
        </data-member>
        <member-function access='private' static='yes'>
          <!-- size_t tcmalloc::SizeMap::ClassIndex() -->
          <function-decl name='ClassIndex' mangled-name='_ZN8tcmalloc7SizeMap10ClassIndexEi' filepath='src/common.h' line='198' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::SizeMap::NumMoveSize(size_t) -->
          <function-decl name='NumMoveSize' mangled-name='_ZN8tcmalloc7SizeMap11NumMoveSizeEm' filepath='src/common.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7SizeMap11NumMoveSizeEm'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private' constructor='yes'>
          <!-- tcmalloc::SizeMap::SizeMap() -->
          <function-decl name='SizeMap' filepath='src/common.h' line='220' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- void tcmalloc::SizeMap::Init() -->
          <function-decl name='Init' mangled-name='_ZN8tcmalloc7SizeMap4InitEv' filepath='src/common.h' line='223' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc7SizeMap4InitEv'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- void -->
            <return type-id='type-id-56'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::SizeMap::SizeClass(int) -->
          <function-decl name='SizeClass' mangled-name='_ZN8tcmalloc7SizeMap9SizeClassEi' filepath='src/common.h' line='225' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'int' -->
            <parameter type-id='type-id-1'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::SizeMap::ByteSizeForClass(size_t) -->
          <function-decl name='ByteSizeForClass' mangled-name='_ZN8tcmalloc7SizeMap16ByteSizeForClassEm' filepath='src/common.h' line='230' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::SizeMap::class_to_size(size_t) -->
          <function-decl name='class_to_size' mangled-name='_ZN8tcmalloc7SizeMap13class_to_sizeEm' filepath='src/common.h' line='235' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- size_t tcmalloc::SizeMap::class_to_pages(size_t) -->
          <function-decl name='class_to_pages' mangled-name='_ZN8tcmalloc7SizeMap14class_to_pagesEm' filepath='src/common.h' line='240' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- typedef size_t -->
            <return type-id='type-id-57'/>
          </function-decl>
        </member-function>
        <member-function access='private'>
          <!-- int tcmalloc::SizeMap::num_objects_to_move(size_t) -->
          <function-decl name='num_objects_to_move' mangled-name='_ZN8tcmalloc7SizeMap19num_objects_to_moveEm' filepath='src/common.h' line='249' column='1' visibility='default' binding='global' size-in-bits='64'>
            <!-- implicit parameter of type 'tcmalloc::SizeMap*' -->
            <parameter type-id='type-id-1482' is-artificial='yes'/>
            <!-- parameter of type 'typedef size_t' -->
            <parameter type-id='type-id-57'/>
            <!-- int -->
            <return type-id='type-id-1'/>
          </function-decl>
        </member-function>
      </class-decl>
      <!-- struct tcmalloc::Span -->
      <class-decl name='Span' size-in-bits='384' is-struct='yes' visibility='default' filepath='src/span.h' line='45' column='1' id='type-id-138'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- PageID tcmalloc::Span::start -->
          <var-decl name='start' type-id='type-id-142' visibility='default' filepath='src/span.h' line='46' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- Length tcmalloc::Span::length -->
          <var-decl name='length' type-id='type-id-143' visibility='default' filepath='src/span.h' line='47' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- tcmalloc::Span* tcmalloc::Span::next -->
          <var-decl name='next' type-id='type-id-144' visibility='default' filepath='src/span.h' line='48' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='192'>
          <!-- tcmalloc::Span* tcmalloc::Span::prev -->
          <var-decl name='prev' type-id='type-id-144' visibility='default' filepath='src/span.h' line='49' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='256'>
          <!-- void* tcmalloc::Span::objects -->
          <var-decl name='objects' type-id='type-id-53' visibility='default' filepath='src/span.h' line='50' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='16'>
          <!-- unsigned int tcmalloc::Span::refcount -->
          <var-decl name='refcount' type-id='type-id-59' visibility='default' filepath='src/span.h' line='51' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='8'>
          <!-- unsigned int tcmalloc::Span::sizeclass -->
          <var-decl name='sizeclass' type-id='type-id-59' visibility='default' filepath='src/span.h' line='52' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='6'>
          <!-- unsigned int tcmalloc::Span::location -->
          <var-decl name='location' type-id='type-id-59' visibility='default' filepath='src/span.h' line='53' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='5'>
          <!-- unsigned int tcmalloc::Span::sample -->
          <var-decl name='sample' type-id='type-id-59' visibility='default' filepath='src/span.h' line='54' column='1'/>
        </data-member>
      </class-decl>
      <!-- struct tcmalloc::StackTrace -->
      <class-decl name='StackTrace' size-in-bits='2112' is-struct='yes' visibility='default' filepath='src/common.h' line='266' column='1' id='type-id-1234'>
        <data-member access='public' layout-offset-in-bits='0'>
          <!-- uintptr_t tcmalloc::StackTrace::size -->
          <var-decl name='size' type-id='type-id-145' visibility='default' filepath='src/common.h' line='267' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='64'>
          <!-- uintptr_t tcmalloc::StackTrace::depth -->
          <var-decl name='depth' type-id='type-id-145' visibility='default' filepath='src/common.h' line='268' column='1'/>
        </data-member>
        <data-member access='public' layout-offset-in-bits='128'>
          <!-- void* tcmalloc::StackTrace::stack[31] -->
          <var-decl name='stack' type-id='type-id-1247' visibility='default' filepath='src/common.h' line='269' column='1'/>
        </data-member>
      </class-decl>
      <!-- enum tcmalloc::LogMode -->
      <enum-decl name='LogMode' filepath='src/internal_logging.h' line='61' column='1' id='type-id-1512'>
        <underlying-type type-id='type-id-84'/>
        <enumerator name='kLog' value='0'/>
        <enumerator name='kCrash' value='1'/>
        <enumerator name='kCrashWithStats' value='2'/>
      </enum-decl>
      <!-- int tcmalloc::AlignmentForSize(size_t) -->
      <function-decl name='AlignmentForSize' mangled-name='_ZN8tcmalloc16AlignmentForSizeEm' filepath='src/common.h' line='158' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc16AlignmentForSizeEm'>
        <!-- parameter of type 'typedef size_t' -->
        <parameter type-id='type-id-57'/>
        <!-- int -->
        <return type-id='type-id-1'/>
      </function-decl>
      <!-- void tcmalloc::Log(tcmalloc::LogMode, const char*, int, tcmalloc::LogItem, tcmalloc::LogItem, tcmalloc::LogItem, tcmalloc::LogItem) -->
      <function-decl name='Log' mangled-name='_ZN8tcmalloc3LogENS_7LogModeEPKciNS_7LogItemES3_S3_S3_' filepath='src/internal_logging.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='_ZN8tcmalloc3LogENS_7LogModeEPKciNS_7LogItemES3_S3_S3_'>
        <!-- parameter of type 'enum tcmalloc::LogMode' -->
        <parameter type-id='type-id-1512'/>
        <!-- parameter of type 'const char*' -->
        <parameter type-id='type-id-52'/>
        <!-- parameter of type 'int' -->
        <parameter type-id='type-id-1'/>
        <!-- parameter of type 'class tcmalloc::LogItem' -->
        <parameter type-id='type-id-1019'/>
        <!-- parameter of type 'class tcmalloc::LogItem' -->
        <parameter type-id='type-id-1019'/>
        <!-- parameter of type 'class tcmalloc::LogItem' -->
        <parameter type-id='type-id-1019'/>
        <!-- parameter of type 'class tcmalloc::LogItem' -->
        <parameter type-id='type-id-1019'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void tcmalloc::SLL_SetNext(void*, void*) -->
      <function-decl name='SLL_SetNext' filepath='src/linked_list.h' line='48' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void* tcmalloc::SLL_Next(void*) -->
      <function-decl name='SLL_Next' filepath='src/linked_list.h' line='44' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- void* -->
        <return type-id='type-id-53'/>
      </function-decl>
      <!-- void tcmalloc::SLL_Push(void**, void*) -->
      <function-decl name='SLL_Push' filepath='src/linked_list.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void*' -->
        <parameter type-id='type-id-53'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- void* tcmalloc::SLL_Pop(void**) -->
      <function-decl name='SLL_Pop' filepath='src/linked_list.h' line='57' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void* -->
        <return type-id='type-id-53'/>
      </function-decl>
      <!-- Length tcmalloc::pages(size_t) -->
      <function-decl name='pages' filepath='src/common.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'typedef size_t' -->
        <parameter type-id='type-id-57'/>
        <!-- typedef Length -->
        <return type-id='type-id-143'/>
      </function-decl>
      <!-- namespace tcmalloc::commandlineflags -->
      <namespace-decl name='commandlineflags'>
        <!-- long long int tcmalloc::commandlineflags::StringToLongLong(const char*, long long int) -->
        <function-decl name='StringToLongLong' filepath='src/base/commandlineflags.h' line='132' column='1' visibility='default' binding='global' size-in-bits='64'>
          <!-- parameter of type 'const char*' -->
          <parameter type-id='type-id-52'/>
          <!-- parameter of type 'long long int' -->
          <parameter type-id='type-id-1029'/>
          <!-- long long int -->
          <return type-id='type-id-1029'/>
        </function-decl>
      </namespace-decl>
    </namespace-decl>
    <!-- namespace FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead -->
    <namespace-decl name='FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead'>
      <!-- int64 FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_tcmalloc_large_alloc_report_threshold -->
      <var-decl name='FLAGS_tcmalloc_large_alloc_report_threshold' type-id='type-id-93' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead43FLAGS_tcmalloc_large_alloc_report_thresholdE' visibility='default' filepath='src/tcmalloc.cc' line='183' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead43FLAGS_tcmalloc_large_alloc_report_thresholdE'/>
      <!-- char FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead::FLAGS_notcmalloc_large_alloc_report_threshold -->
      <var-decl name='FLAGS_notcmalloc_large_alloc_report_threshold' type-id='type-id-60' mangled-name='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead45FLAGS_notcmalloc_large_alloc_report_thresholdE' visibility='default' filepath='src/tcmalloc.cc' line='195' column='1' elf-symbol-id='_ZN61FLAG__namespace_do_not_use_directly_use_DECLARE_int64_instead45FLAGS_notcmalloc_large_alloc_report_thresholdE'/>
    </namespace-decl>
    <!-- const char* tc_version(int*, int*, const char**) -->
    <function-decl name='tc_version' mangled-name='tc_version' filepath='src/tcmalloc.cc' line='1547' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_version'>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='major' filepath='src/tcmalloc.cc' line='1548' column='1'/>
      <!-- parameter of type 'int*' -->
      <parameter type-id='type-id-871' name='minor' filepath='src/tcmalloc.cc' line='1548' column='1'/>
      <!-- parameter of type 'const char**' -->
      <parameter type-id='type-id-1426' name='patch' filepath='src/tcmalloc.cc' line='1548' column='1'/>
      <!-- const char* -->
      <return type-id='type-id-52'/>
    </function-decl>
    <!-- int tc_set_new_mode(int) -->
    <function-decl name='tc_set_new_mode' mangled-name='tc_set_new_mode' filepath='src/tcmalloc.cc' line='1560' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_set_new_mode'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='flag' filepath='src/tcmalloc.cc' line='1560' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- int tc_mallopt(int, int) -->
    <function-decl name='tc_mallopt' mangled-name='tc_mallopt' filepath='src/tcmalloc.cc' line='1720' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_mallopt'>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='cmd' filepath='src/tcmalloc.cc' line='1720' column='1'/>
      <!-- parameter of type 'int' -->
      <parameter type-id='type-id-1' name='value' filepath='src/tcmalloc.cc' line='1720' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- size_t tc_malloc_size(void*) -->
    <function-decl name='tc_malloc_size' mangled-name='tc_malloc_size' filepath='src/tcmalloc.cc' line='1730' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_malloc_size'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='ptr' filepath='src/tcmalloc.cc' line='1730' column='1'/>
      <!-- typedef size_t -->
      <return type-id='type-id-57'/>
    </function-decl>
    <!-- void tc_malloc_stats() -->
    <function-decl name='tc_malloc_stats' mangled-name='tc_malloc_stats' filepath='src/tcmalloc.cc' line='1716' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_malloc_stats'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- mallinfo tc_mallinfo() -->
    <function-decl name='tc_mallinfo' mangled-name='tc_mallinfo' filepath='src/tcmalloc.cc' line='1725' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_mallinfo'>
      <!-- struct mallinfo -->
      <return type-id='type-id-1417'/>
    </function-decl>
    <!-- int tc_posix_memalign(void**, size_t, size_t) -->
    <function-decl name='tc_posix_memalign' mangled-name='tc_posix_memalign' filepath='src/tcmalloc.cc' line='1676' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_posix_memalign'>
      <!-- parameter of type 'void**' -->
      <parameter type-id='type-id-141' name='result_ptr' filepath='src/tcmalloc.cc' line='1677' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='align' filepath='src/tcmalloc.cc' line='1677' column='1'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='size' filepath='src/tcmalloc.cc' line='1677' column='1'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-decl>
    <!-- void* tc_pvalloc(size_t) -->
    <function-decl name='tc_pvalloc' mangled-name='tc_pvalloc' filepath='src/tcmalloc.cc' line='1704' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_pvalloc'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_valloc(size_t) -->
    <function-decl name='tc_valloc' mangled-name='tc_valloc' filepath='src/tcmalloc.cc' line='1696' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_valloc'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_memalign(size_t, size_t) -->
    <function-decl name='tc_memalign' mangled-name='tc_memalign' filepath='src/tcmalloc.cc' line='1669' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_memalign'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_newarray_nothrow(size_t, const std::nothrow_t&) -->
    <function-decl name='tc_newarray_nothrow' mangled-name='tc_newarray_nothrow' filepath='src/tcmalloc.cc' line='1652' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_newarray_nothrow'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='size' filepath='src/tcmalloc.cc' line='1652' column='1'/>
      <!-- parameter of type 'const std::nothrow_t&' -->
      <parameter type-id='type-id-1436'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_newarray(size_t) -->
    <function-decl name='tc_newarray' mangled-name='tc_newarray' filepath='src/tcmalloc.cc' line='1641' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_newarray'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_new_nothrow(size_t, const std::nothrow_t&) -->
    <function-decl name='tc_new_nothrow' mangled-name='tc_new_nothrow' filepath='src/tcmalloc.cc' line='1622' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_new_nothrow'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57' name='size' filepath='src/tcmalloc.cc' line='1652' column='1'/>
      <!-- parameter of type 'const std::nothrow_t&' -->
      <parameter type-id='type-id-1436'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_new(size_t) -->
    <function-decl name='tc_new' mangled-name='tc_new' filepath='src/tcmalloc.cc' line='1611' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_new'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_malloc(size_t) -->
    <function-decl name='tc_malloc' mangled-name='tc_malloc' filepath='src/tcmalloc.cc' line='1573' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_malloc'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void* tc_malloc_skip_new_handler(size_t) -->
    <function-decl name='tc_malloc_skip_new_handler' mangled-name='tc_malloc_skip_new_handler' filepath='src/tcmalloc.cc' line='1734' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_malloc_skip_new_handler'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void tc_free(void*) -->
    <function-decl name='tc_free' mangled-name='tc_free' filepath='src/tcmalloc.cc' line='1579' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_free'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void* tc_calloc(size_t, size_t) -->
    <function-decl name='tc_calloc' mangled-name='tc_calloc' filepath='src/tcmalloc.cc' line='1584' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_calloc'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void tc_cfree(void*) -->
    <function-decl name='tc_cfree' mangled-name='tc_cfree' filepath='src/tcmalloc.cc' line='1591' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_cfree'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void tc_delete(void*) -->
    <function-decl name='tc_delete' mangled-name='tc_delete' filepath='src/tcmalloc.cc' line='1628' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_delete'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void tc_delete_nothrow(void*, const std::nothrow_t&) -->
    <function-decl name='tc_delete_nothrow' mangled-name='tc_delete_nothrow' filepath='src/tcmalloc.cc' line='1636' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_delete_nothrow'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='p' filepath='src/tcmalloc.cc' line='1636' column='1'/>
      <!-- parameter of type 'const std::nothrow_t&' -->
      <parameter type-id='type-id-1436'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void tc_deletearray(void*) -->
    <function-decl name='tc_deletearray' mangled-name='tc_deletearray' filepath='src/tcmalloc.cc' line='1659' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_deletearray'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void tc_deletearray_nothrow(void*, const std::nothrow_t&) -->
    <function-decl name='tc_deletearray_nothrow' mangled-name='tc_deletearray_nothrow' filepath='src/tcmalloc.cc' line='1664' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_deletearray_nothrow'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53' name='p' filepath='src/tcmalloc.cc' line='1636' column='1'/>
      <!-- parameter of type 'const std::nothrow_t&' -->
      <parameter type-id='type-id-1436'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-decl>
    <!-- void* tc_realloc(void*, size_t) -->
    <function-decl name='tc_realloc' mangled-name='tc_realloc' filepath='src/tcmalloc.cc' line='1596' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tc_realloc'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-decl>
    <!-- void (void*, void*)* __free_hook -->
    <var-decl name='__free_hook' type-id='type-id-1488' mangled-name='__free_hook' visibility='default' filepath='src/libc_override_glibc.h' line='139' column='1' elf-symbol-id='__free_hook'/>
    <!-- void* (typedef size_t, void*)* __malloc_hook -->
    <var-decl name='__malloc_hook' type-id='type-id-1492' mangled-name='__malloc_hook' visibility='default' filepath='src/libc_override_glibc.h' line='135' column='1' elf-symbol-id='__malloc_hook'/>
    <!-- void* (void*, typedef size_t, void*)* __realloc_hook -->
    <var-decl name='__realloc_hook' type-id='type-id-1494' mangled-name='__realloc_hook' visibility='default' filepath='src/libc_override_glibc.h' line='137' column='1' elf-symbol-id='__realloc_hook'/>
    <!-- void* (typedef size_t, typedef size_t, void*)* __memalign_hook -->
    <var-decl name='__memalign_hook' type-id='type-id-1490' mangled-name='__memalign_hook' visibility='default' filepath='src/libc_override_glibc.h' line='141' column='1' elf-symbol-id='__memalign_hook'/>
    <!-- int (void*, void*) -->
    <function-type size-in-bits='64' id='type-id-1459'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- int -->
      <return type-id='type-id-1'/>
    </function-type>
    <!-- void () -->
    <function-type size-in-bits='64' id='type-id-855'>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*) -->
    <function-type size-in-bits='64' id='type-id-858'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, const base::MallocRange*) -->
    <function-type size-in-bits='64' id='type-id-870'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'const base::MallocRange*' -->
      <parameter type-id='type-id-1425'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, size_t) -->
    <function-type size-in-bits='64' id='type-id-864'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void (void*, void*) -->
    <function-type size-in-bits='64' id='type-id-1487'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void -->
      <return type-id='type-id-56'/>
    </function-type>
    <!-- void* (size_t, size_t, void*) -->
    <function-type size-in-bits='64' id='type-id-1489'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-type>
    <!-- void* (size_t, void*) -->
    <function-type size-in-bits='64' id='type-id-1491'>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-type>
    <!-- void* (unsigned long int) -->
    <function-type size-in-bits='64' id='type-id-865'>
      <!-- parameter of type 'unsigned long int' -->
      <parameter type-id='type-id-5'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-type>
    <!-- void* (void*, size_t, void*) -->
    <function-type size-in-bits='64' id='type-id-1493'>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- parameter of type 'typedef size_t' -->
      <parameter type-id='type-id-57'/>
      <!-- parameter of type 'void*' -->
      <parameter type-id='type-id-53'/>
      <!-- void* -->
      <return type-id='type-id-53'/>
    </function-type>
  </abi-instr>
  <abi-instr version='1.0' address-size='64' path='src/thread_cache.cc' comp-dir-path='/tmp/legendre/spack-stage/spack-stage-kFgaKP/gperftools-2.4' language='LANG_C_plus_plus'>
    <!-- namespace std -->
    <namespace-decl name='std'>
      <!-- const double& std::max<double>(const double&, const double&) -->
      <function-decl name='max&lt;double&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const double&' -->
        <parameter type-id='type-id-1229'/>
        <!-- parameter of type 'const double&' -->
        <parameter type-id='type-id-1229'/>
        <!-- const double& -->
        <return type-id='type-id-1229'/>
      </function-decl>
      <!-- const int& std::min<int>(const int&, const int&) -->
      <function-decl name='min&lt;int&gt;' filepath='/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algobase.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'const int&' -->
        <parameter type-id='type-id-135'/>
        <!-- parameter of type 'const int&' -->
        <parameter type-id='type-id-135'/>
        <!-- const int& -->
        <return type-id='type-id-135'/>
      </function-decl>
    </namespace-decl>
    <!-- namespace tcmalloc -->
    <namespace-decl name='tcmalloc'>
      <!-- void tcmalloc::SLL_PopRange(void**, int, void**, void**) -->
      <function-decl name='SLL_PopRange' filepath='src/linked_list.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'int' -->
        <parameter type-id='type-id-1'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- parameter of type 'void**' -->
        <parameter type-id='type-id-141'/>
        <!-- void -->
        <return type-id='type-id-56'/>
      </function-decl>
      <!-- tcmalloc::PageHeapAllocator<tcmalloc::ThreadCache> tcmalloc::threadcache_allocator -->
      <var-decl name='threadcache_allocator' type-id='type-id-1446' mangled-name='_ZN8tcmalloc21threadcache_allocatorE' visibility='default' filepath='src/thread_cache.cc' line='67' column='1' elf-symbol-id='_ZN8tcmalloc21threadcache_allocatorE'/>
    </namespace-decl>
  </abi-instr>
</abi-corpus>
