From cd731a3798219107c1cefacf3d1d80c2bca28998 Mon Sep 17 00:00:00 2001
From: mlangkabel <malte.langkabel@gmail.com>
Date: Mon, 30 Sep 2019 11:43:27 +0200
Subject: [PATCH] logic: skip traversing unspecialized template method of
 implicit template class specialization

---
 ...ision_BroadPhaseCollision_b3DynamicBvh.txt | 112 -----------
 ...dPhaseCollision_b3DynamicBvhBroadphase.txt | 116 +-----------
 ...dPhaseCollision_b3OverlappingPairCache.txt |  36 +---
 ...n_NarrowPhaseCollision_b3ConvexUtility.txt | 114 +-----------
 ..._NarrowPhaseCollision_b3CpuNarrowPhase.txt | 176 ------------------
 .../Bullet3Geometry_b3ConvexHullComputer.txt  | 100 +---------
 .../Bullet3Geometry_b3GeometryUtil.txt        |  16 --
 src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp |  19 +-
 src/lib_cxx/data/parser/cxx/CxxAstVisitor.h   |   1 +
 .../cxx/CxxAstVisitorComponentIndexer.cpp     |  57 ++++--
 src/test/CxxParserTestSuite.h                 |  29 ++-
 11 files changed, 100 insertions(+), 676 deletions(-)

diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvh.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvh.txt
index f7bf533e..560303c7 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvh.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvh.txt
@@ -311,7 +311,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer b3Al
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -332,7 +331,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::pointer b3Alig
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::construct(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<const b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<const b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -352,7 +350,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -371,7 +368,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer b3A
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -390,7 +386,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer b3Al
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DbvtNode *, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -408,7 +403,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtNode *, 16>::pointer b3AlignedAll
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::construct(b3AlignedAllocator<b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -429,7 +423,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer b3A
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -510,11 +503,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::push_back
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch2(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -552,11 +541,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::push_back(c
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<const b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch2(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -594,11 +579,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -638,11 +619,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::push_bac
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch2(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -680,11 +657,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::push_back
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch2(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -722,11 +695,7 @@ SYMBOL_METHOD: public b3DbvtNode * & b3AlignedObjectArray<b3DbvtNode *>::expand(
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::push_back(b3DbvtNode * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findLinearSearch(b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findLinearSearch2(b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -766,11 +735,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::push_bac
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findLinearSearch(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findLinearSearch2(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2671,8 +2636,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2714,8 +2677,6 @@ REFERENCE_CALL: void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3Al
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<const b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2751,8 +2712,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2794,8 +2753,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2831,8 +2788,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::dealloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2874,8 +2829,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DbvtNode *, 16>::deallocate(b3AlignedA
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2917,8 +2870,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::deallocate(b
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3219,19 +3170,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3395,19 +3337,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) ->
 REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> const b3DbvtNode * * b3AlignedObjectArray<const b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<const b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<const b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3523,19 +3456,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::reserve(int)
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3682,19 +3606,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int)
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> b3DynamicBvh::sStkNPS * b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3797,19 +3712,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3982,14 +3888,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> bool b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3999,7 +3897,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3Db
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <422:4 422:9>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <422:21 422:26>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4161,19 +4058,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int)
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) -> b3DynamicBvh::sStkCLN * b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> b3DynamicBvh::sStkCLN [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> b3DynamicBvh::sStkCLN [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvhBroadphase.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvhBroadphase.txt
index 1597a140..15c78e07 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvhBroadphase.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvhBroadphase.txt
@@ -300,7 +300,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer b3Al
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -321,7 +320,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::pointer b3Alig
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::construct(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<const b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<const b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -341,7 +339,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -360,7 +357,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer b3A
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -379,7 +375,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer b3Al
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3Int4, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -398,7 +393,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_CLASS: b3AlignedAllocator<b3DbvtProxy, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -417,7 +411,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtProxy, 16>::pointer b3AlignedAllo
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::construct(b3AlignedAllocator<b3DbvtProxy, 16>::pointer, const b3AlignedAllocator<b3DbvtProxy, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::deallocate(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DbvtProxy, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -499,11 +492,7 @@ SYMBOL_METHOD: public b3DynamicBvh::sStkNN & b3AlignedObjectArray<b3DynamicBvh::
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::push_back(const b3DynamicBvh::sStkNN &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch2(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -541,11 +530,7 @@ SYMBOL_METHOD: public const b3DbvtNode * & b3AlignedObjectArray<const b3DbvtNode
 SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::push_back(const b3DbvtNode * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<const b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch2(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -583,11 +568,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -627,11 +608,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::push_bac
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch2(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -669,11 +646,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::push_back
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch2(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -714,16 +687,12 @@ SYMBOL_METHOD: public b3Int4 & b3AlignedObjectArray<b3Int4>::expand(const b3Int4
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4 &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
 SYMBOL_CLASS: b3BroadphasePairSortPredicate [b3OverlappingPair.h <52:1 <52:7 52:35> 64:1>]
 SYMBOL_METHOD: public bool b3BroadphasePairSortPredicate::operator()(const b3BroadphasePair &, const b3BroadphasePair &) const [b3OverlappingPair.h <56:3 <56:3 <56:8 56:17> 56:80> 63:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public b3Int4 & b3Int4::operator=(const b3Int4 &) [b3Int4.h <26:32 <26:32 26:37> 26:37>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch2(const b3Int4 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -765,11 +734,7 @@ SYMBOL_METHOD: public b3DbvtProxy & b3AlignedObjectArray<b3DbvtProxy>::expand(co
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::push_back(const b3DbvtProxy &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3DbvtProxy>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findLinearSearch(const b3DbvtProxy &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findLinearSearch2(const b3DbvtProxy &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -3066,8 +3031,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3109,8 +3072,6 @@ REFERENCE_CALL: void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3Al
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<const b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3146,8 +3107,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3189,8 +3148,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3226,8 +3183,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::dealloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3269,8 +3224,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocat
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3312,8 +3265,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DbvtProxy, 16>::deallocate(b3AlignedAl
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> b3AlignedAllocator<b3DbvtProxy, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3648,19 +3599,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> b3DynamicBvh::sStkNN * b3AlignedObjectArray<b3DynamicBvh::sStkNN>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3837,19 +3779,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) ->
 REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> const b3DbvtNode * * b3AlignedObjectArray<const b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<const b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<const b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3962,19 +3895,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::reserve(int)
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4121,19 +4045,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int)
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> b3DynamicBvh::sStkNPS * b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4236,19 +4151,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4397,10 +4303,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> bool b3Align
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int b3AlignedObjectArray<b3Int4>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <341:32 341:32>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -4416,17 +4319,12 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3Broadphas
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <371:24 371:24>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -4439,7 +4337,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <422:19 422:19>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <423:19 423:19>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4602,19 +4499,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> bool b3
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> b3DbvtProxy * b3AlignedObjectArray<b3DbvtProxy>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> int b3AlignedObjectArray<b3DbvtProxy>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DbvtProxy>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> b3DbvtProxy [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> b3DbvtProxy [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3OverlappingPairCache.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3OverlappingPairCache.txt
index f448973c..afc29177 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3OverlappingPairCache.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3OverlappingPairCache.txt
@@ -287,7 +287,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Int4, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -307,7 +306,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -388,16 +386,12 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::reserve(int) [b3Aligned
 SYMBOL_METHOD: public b3Int4 & b3AlignedObjectArray<b3Int4>::expand(const b3Int4 &) [b3AlignedObjectArray.h <260:3 <260:23 260:28> 273:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
 SYMBOL_CLASS: b3BroadphasePairSortPredicate [b3OverlappingPair.h <52:1 <52:7 52:35> 64:1>]
 SYMBOL_METHOD: public bool b3BroadphasePairSortPredicate::operator()(const b3BroadphasePair &, const b3BroadphasePair &) const [b3OverlappingPair.h <56:3 <56:3 <56:8 56:17> 56:80> 63:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public b3Int4 & b3Int4::operator=(const b3Int4 &) [b3Int4.h <26:32 <26:32 26:37> 26:37>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
 SYMBOL_FUNCTION: bool operator==(const b3BroadphasePair &, const b3BroadphasePair &) [b3OverlappingPair.h <66:1 <66:1 <66:22 66:31> 66:85> 69:1>]
@@ -436,11 +430,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2271,8 +2261,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocat
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2314,8 +2302,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2658,10 +2644,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> bool b3Align
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int b3AlignedObjectArray<b3Int4>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <341:32 341:32>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -2677,17 +2660,12 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3Broadphas
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <371:24 371:24>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -2700,7 +2678,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <422:19 422:19>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <423:19 423:19>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -2865,19 +2842,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3ConvexUtility.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3ConvexUtility.txt
index e504119c..0578f035 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3ConvexUtility.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3ConvexUtility.txt
@@ -306,7 +306,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -341,7 +340,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Vector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -362,7 +360,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::pointer b3AlignedAllocat
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::construct(b3AlignedAllocator<b3MyFace, 16>::pointer, const b3AlignedAllocator<b3MyFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3MyFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -386,7 +383,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointe
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::construct(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::deallocate(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -407,7 +403,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3GrahamVector3, 16>::pointer b3Aligned
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::construct(b3AlignedAllocator<b3GrahamVector3, 16>::pointer, const b3AlignedAllocator<b3GrahamVector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::deallocate(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3GrahamVector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -428,7 +423,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3InternalEdge, 16>::pointer b3AlignedA
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::construct(b3AlignedAllocator<b3InternalEdge, 16>::pointer, const b3AlignedAllocator<b3InternalEdge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::deallocate(b3AlignedAllocator<b3InternalEdge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3InternalEdge, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -449,7 +443,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3InternalVertexPair, 16>::pointer b3Al
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::construct(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer, const b3AlignedAllocator<b3InternalVertexPair, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::deallocate(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3InternalVertexPair, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -528,11 +521,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -573,11 +562,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -618,11 +603,7 @@ SYMBOL_METHOD: public b3MyFace & b3AlignedObjectArray<b3MyFace>::expand(const b3
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::push_back(const b3MyFace &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3MyFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch(const b3MyFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch2(const b3MyFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -661,11 +642,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::pus
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch2(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -705,15 +682,11 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::push_back(cons
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3GrahamVector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
 SYMBOL_STRUCT: b3AngleCompareFunc [b3GrahamScan2dConvexHull.h <36:1 <36:8 36:25> 57:1>]
 SYMBOL_METHOD: public bool b3AngleCompareFunc::operator()(const b3GrahamVector3 &, const b3GrahamVector3 &) const [b3GrahamScan2dConvexHull.h <42:2 <42:2 <42:7 42:16> 42:74> 56:2>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3GrahamScan2dConvexHull.h <24:8 <24:8 24:22> 24:22>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findLinearSearch(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findLinearSearch2(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -753,11 +726,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::push_back(const
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3InternalEdge>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findLinearSearch(const b3InternalEdge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findLinearSearch2(const b3InternalEdge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -797,11 +766,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::push_back
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3InternalVertexPair>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findLinearSearch(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findLinearSearch2(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2586,8 +2551,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2629,8 +2592,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2672,8 +2633,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAlloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> b3AlignedAllocator<b3MyFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2711,8 +2670,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::dealloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2754,8 +2711,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3GrahamVector3, 16>::deallocate(b3Align
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> b3AlignedAllocator<b3GrahamVector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2797,8 +2752,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3InternalEdge, 16>::deallocate(b3Aligne
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> b3AlignedAllocator<b3InternalEdge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2840,8 +2793,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3InternalVertexPair, 16>::deallocate(b3
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> b3AlignedAllocator<b3InternalVertexPair, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3201,14 +3152,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3218,7 +3161,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3Align
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <422:4 422:9>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <422:21 422:26>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3404,19 +3346,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3589,19 +3522,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> bool b3Ali
 REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> b3MyFace * b3AlignedObjectArray<b3MyFace>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> int b3AlignedObjectArray<b3MyFace>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3MyFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> b3MyFace [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> b3MyFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3727,19 +3651,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullCompute
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3904,10 +3819,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> boo
 REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> b3GrahamVector3 * b3AlignedObjectArray<b3GrahamVector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> int b3AlignedObjectArray<b3GrahamVector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3GrahamVector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> b3AngleCompareFunc [b3AlignedObjectArray.h <341:32 341:32>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -3923,11 +3835,6 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3
 REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> b3GrahamVector3 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3940,7 +3847,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 * b3AlignedObjectArray<b3GrahamVector3>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3AlignedObjectArray.h <422:19 422:19>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3AlignedObjectArray.h <423:19 423:19>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> b3GrahamVector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4098,19 +4004,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> bool
 REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> b3InternalEdge * b3AlignedObjectArray<b3InternalEdge>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> int b3AlignedObjectArray<b3InternalEdge>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3InternalEdge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> b3InternalEdge [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> b3InternalEdge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4269,19 +4166,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -
 REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -> b3InternalVertexPair * b3AlignedObjectArray<b3InternalVertexPair>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -> int b3AlignedObjectArray<b3InternalVertexPair>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3InternalVertexPair>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> b3InternalVertexPair [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> b3InternalVertexPair [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3CpuNarrowPhase.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3CpuNarrowPhase.txt
index 0849adac..898ceb0b 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3CpuNarrowPhase.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3CpuNarrowPhase.txt
@@ -296,7 +296,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -331,7 +330,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Vector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -352,7 +350,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::pointer b3AlignedAllocat
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::construct(b3AlignedAllocator<b3MyFace, 16>::pointer, const b3AlignedAllocator<b3MyFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3MyFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -374,7 +371,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3GpuFace, 16>::pointer b3AlignedAlloca
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::construct(b3AlignedAllocator<b3GpuFace, 16>::pointer, const b3AlignedAllocator<b3GpuFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::deallocate(b3AlignedAllocator<b3GpuFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3GpuFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -396,7 +392,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Collidable, 16>::pointer b3AlignedAll
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::construct(b3AlignedAllocator<b3Collidable, 16>::pointer, const b3AlignedAllocator<b3Collidable, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::deallocate(b3AlignedAllocator<b3Collidable, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Collidable, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -418,7 +413,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer b3
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::construct(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::deallocate(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexPolyhedronData, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -440,7 +434,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Contact4Data, 16>::pointer b3AlignedA
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::construct(b3AlignedAllocator<b3Contact4Data, 16>::pointer, const b3AlignedAllocator<b3Contact4Data, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::deallocate(b3AlignedAllocator<b3Contact4Data, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Contact4Data, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -462,7 +455,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3RigidBodyData, 16>::pointer b3Aligned
 SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::construct(b3AlignedAllocator<b3RigidBodyData, 16>::pointer, const b3AlignedAllocator<b3RigidBodyData, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::deallocate(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_CLASS: b3AlignedAllocator<b3Aabb, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
 SYMBOL_TYPEDEF: private b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -481,7 +473,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Aabb, 16>::pointer b3AlignedAllocator
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::construct(b3AlignedAllocator<b3Aabb, 16>::pointer, const b3AlignedAllocator<b3Aabb, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::deallocate(b3AlignedAllocator<b3Aabb, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Aabb, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -503,7 +494,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexUtility *, 16>::pointer b3Align
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::construct(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer, const b3AlignedAllocator<b3ConvexUtility *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::deallocate(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexUtility *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -524,7 +514,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_GLOBAL_VARIABLE: const __m128 b3vMzeroMask [b3Vector3.h <58:37 58:48>]
 SYMBOL_GLOBAL_VARIABLE: const __m128 b3v1110 [b3Vector3.h <59:37 59:43>]
@@ -1081,11 +1070,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1123,11 +1108,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1166,11 +1147,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch2(const b3Int4 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1210,11 +1187,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::push_back(const b3Aabb
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Aabb>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findLinearSearch(const b3Aabb &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findLinearSearch2(const b3Aabb &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1252,11 +1225,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::push_back(cons
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3RigidBodyData>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findLinearSearch(const b3RigidBodyData &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findLinearSearch2(const b3RigidBodyData &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1297,11 +1266,7 @@ SYMBOL_METHOD: public b3Contact4Data & b3AlignedObjectArray<b3Contact4Data>::exp
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::push_back(const b3Contact4Data &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Contact4Data>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findLinearSearch(const b3Contact4Data &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findLinearSearch2(const b3Contact4Data &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1340,11 +1305,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::push_back(const b3MyF
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3MyFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch(const b3MyFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch2(const b3MyFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1385,11 +1346,7 @@ SYMBOL_METHOD: public b3GpuFace & b3AlignedObjectArray<b3GpuFace>::expand(const
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::push_back(const b3GpuFace &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3GpuFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findLinearSearch(const b3GpuFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findLinearSearch2(const b3GpuFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1430,11 +1387,7 @@ SYMBOL_METHOD: public b3ConvexPolyhedronData & b3AlignedObjectArray<b3ConvexPoly
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::push_back(const b3ConvexPolyhedronData &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexPolyhedronData>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findLinearSearch(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findLinearSearch2(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1472,11 +1425,7 @@ SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::capacity() const [
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::push_back(const b3Collidable &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Collidable>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findLinearSearch(const b3Collidable &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findLinearSearch2(const b3Collidable &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1514,11 +1463,7 @@ SYMBOL_METHOD: public b3ConvexUtility * & b3AlignedObjectArray<b3ConvexUtility *
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::push_back(b3ConvexUtility * const &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexUtility *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findLinearSearch(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findLinearSearch2(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -3134,8 +3079,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3177,8 +3120,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3216,8 +3157,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAlloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> b3AlignedAllocator<b3MyFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3259,8 +3198,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3GpuFace, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> b3AlignedAllocator<b3GpuFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3302,8 +3239,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Collidable, 16>::deallocate(b3AlignedA
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> b3AlignedAllocator<b3Collidable, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3345,8 +3280,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::deallocate(
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3388,8 +3321,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Contact4Data, 16>::deallocate(b3Aligne
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> b3AlignedAllocator<b3Contact4Data, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3425,8 +3356,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::deallocate(b
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> b3AlignedAllocator<b3RigidBodyData, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3468,8 +3397,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Aabb, 16>::deallocate(b3AlignedAllocat
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> b3AlignedAllocator<b3Aabb, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3511,8 +3438,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexUtility *, 16>::deallocate(b3Ali
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> b3AlignedAllocator<b3ConvexUtility *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3548,8 +3473,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedA
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -6858,19 +6781,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7040,19 +6954,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7159,19 +7064,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::reserve(in
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7331,19 +7227,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> bool b3Align
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> b3Aabb * b3AlignedObjectArray<b3Aabb>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> int b3AlignedObjectArray<b3Aabb>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Aabb>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> b3Aabb [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> b3Aabb [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7452,19 +7339,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3RigidBodyData>::r
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3RigidBodyData>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> b3RigidBodyData [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> b3RigidBodyData [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7642,19 +7520,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> bool
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> b3Contact4Data * b3AlignedObjectArray<b3Contact4Data>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> int b3AlignedObjectArray<b3Contact4Data>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Contact4Data>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> b3Contact4Data [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> b3Contact4Data [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7780,19 +7649,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::reserve(
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3MyFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> b3MyFace [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> b3MyFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7962,19 +7822,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> bool b3Al
 REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> b3GpuFace * b3AlignedObjectArray<b3GpuFace>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> int b3AlignedObjectArray<b3GpuFace>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3GpuFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> b3GpuFace [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> b3GpuFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8140,19 +7991,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int)
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int) -> b3ConvexPolyhedronData * b3AlignedObjectArray<b3ConvexPolyhedronData>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int) -> int b3AlignedObjectArray<b3ConvexPolyhedronData>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexPolyhedronData>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> b3ConvexPolyhedronData [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> b3ConvexPolyhedronData [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8316,19 +8158,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> bool b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> b3Collidable * b3AlignedObjectArray<b3Collidable>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> int b3AlignedObjectArray<b3Collidable>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Collidable>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> b3Collidable [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> b3Collidable [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8486,19 +8319,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> b
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> b3ConvexUtility * * b3AlignedObjectArray<b3ConvexUtility *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexUtility *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexUtility *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> b3ConvexUtility [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> b3ConvexUtility [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3ConvexHullComputer.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3ConvexHullComputer.txt
index f50dbb9d..9e66d7a8 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3ConvexHullComputer.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3ConvexHullComputer.txt
@@ -296,7 +296,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_CLASS: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
 SYMBOL_TYPEDEF: private b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -316,7 +315,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointe
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::construct(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::deallocate(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_CLASS: b3AlignedAllocator<int, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
 SYMBOL_TYPEDEF: private b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -333,7 +331,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_CLASS: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
 SYMBOL_TYPEDEF: private b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -351,7 +348,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::po
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -372,7 +368,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::poi
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -392,7 +387,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::poin
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -626,11 +620,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -671,11 +661,7 @@ SYMBOL_METHOD: public b3ConvexHullComputer::Edge & b3AlignedObjectArray<b3Convex
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::push_back(const b3ConvexHullComputer::Edge &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch2(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -713,11 +699,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -755,11 +737,7 @@ SYMBOL_METHOD: public b3ConvexHullInternal::Vertex * & b3AlignedObjectArray<b3Co
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::push_back(b3ConvexHullInternal::Vertex * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findLinearSearch(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findLinearSearch2(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -800,14 +778,10 @@ SYMBOL_METHOD: public b3ConvexHullInternal::Point32 & b3AlignedObjectArray<b3Con
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::push_back(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Point32>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3ConvexHullComputer.cpp <82:9 <82:9 82:15> 82:15>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findLinearSearch(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findLinearSearch2(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -845,11 +819,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::p
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Face *>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findLinearSearch(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findLinearSearch2(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2159,8 +2129,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2202,8 +2170,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::dealloc
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2245,8 +2211,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2288,8 +2252,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::dea
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2331,8 +2293,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::deal
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2374,8 +2334,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::deall
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3561,19 +3519,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3741,19 +3690,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> b3ConvexHullComputer::Edge * b3AlignedObjectArray<b3ConvexHullComputer::Edge>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3916,19 +3856,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4114,19 +4045,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::rese
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::reserve(int) -> b3ConvexHullInternal::Vertex * * b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> b3ConvexHullInternal::Vertex [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> b3ConvexHullInternal::Vertex [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4287,10 +4209,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reser
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reserve(int) -> b3ConvexHullInternal::Point32 * b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Point32>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <341:32 341:32>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -4304,17 +4223,12 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quick
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
+REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <371:24 371:24>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> b3ConvexHullInternal::Point32 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -4327,7 +4241,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 * b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <422:19 422:19>]
 REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <423:19 423:19>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> b3ConvexHullInternal::Point32 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4483,19 +4396,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserv
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) -> b3ConvexHullInternal::Face * * b3AlignedObjectArray<b3ConvexHullInternal::Face *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Face *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> b3ConvexHullInternal::Face [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> b3ConvexHullInternal::Face [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3GeometryUtil.txt b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3GeometryUtil.txt
index 62a7151e..6eac3fed 100644
--- a/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3GeometryUtil.txt
+++ b/bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3GeometryUtil.txt
@@ -248,7 +248,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
 SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
-SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
 SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
 SYMBOL_GLOBAL_VARIABLE: const __m128 b3vMzeroMask [b3Vector3.h <58:37 58:48>]
 SYMBOL_GLOBAL_VARIABLE: const __m128 b3v1110 [b3Vector3.h <59:37 59:43>]
@@ -479,11 +478,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Ve
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
 SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
 SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
-SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
 SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1240,8 +1235,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
 REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
-REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
 REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2421,19 +2414,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
 REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
 REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
 REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
 REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
-REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
 REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
 REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
diff --git a/src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp b/src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp
index ce7d243c..97c56519 100644
--- a/src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp
+++ b/src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp
@@ -66,7 +66,7 @@ CanonicalFilePathCache* CxxAstVisitor::getCanonicalFilePathCache() const
 void CxxAstVisitor::indexDecl(clang::Decl* d)
 {
 	LOG_INFO("starting AST traversal");
-
+	//d->dump();
 	this->TraverseDecl(d);
 }
 
@@ -236,6 +236,23 @@ bool CxxAstVisitor::traverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& d)
 	return ret;
 }
 
+bool CxxAstVisitor::TraverseCXXMethodDecl(clang::CXXMethodDecl* d)
+{
+	if (d->getTemplatedKind() == clang::CXXMethodDecl::TK_FunctionTemplate)
+	{
+		if (clang::CXXRecordDecl* recordDecl = d->getParent())
+		{
+			if (!clang::isa<clang::ClassTemplatePartialSpecializationDecl>(recordDecl) &&
+				clang::isa<clang::ClassTemplateSpecializationDecl>(recordDecl) &&
+				!clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(recordDecl)->isExplicitSpecialization())
+			{
+				return true; // we skip visiting an implicit definition of a template method and its contents
+			}
+		}
+	}
+	return Base::TraverseCXXMethodDecl(d);
+}
+
 // same as Base::TraverseTemplateTypeParmDecl(..) but we need to integrate the setter for the context info.
 bool CxxAstVisitor::TraverseTemplateTypeParmDecl(clang::TemplateTypeParmDecl* d)
 {
diff --git a/src/lib_cxx/data/parser/cxx/CxxAstVisitor.h b/src/lib_cxx/data/parser/cxx/CxxAstVisitor.h
index b4042341..34879f9b 100644
--- a/src/lib_cxx/data/parser/cxx/CxxAstVisitor.h
+++ b/src/lib_cxx/data/parser/cxx/CxxAstVisitor.h
@@ -67,6 +67,7 @@ public:
 
 	virtual bool TraverseCXXRecordDecl(clang::CXXRecordDecl* d);
 	bool traverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& d);
+	virtual bool TraverseCXXMethodDecl(clang::CXXMethodDecl* d);
 	virtual bool TraverseTemplateTypeParmDecl(clang::TemplateTypeParmDecl* d);
 	virtual bool TraverseTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl* d);
 	virtual bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc);
diff --git a/src/lib_cxx/data/parser/cxx/CxxAstVisitorComponentIndexer.cpp b/src/lib_cxx/data/parser/cxx/CxxAstVisitorComponentIndexer.cpp
index 59a47f21..fb851e87 100644
--- a/src/lib_cxx/data/parser/cxx/CxxAstVisitorComponentIndexer.cpp
+++ b/src/lib_cxx/data/parser/cxx/CxxAstVisitorComponentIndexer.cpp
@@ -191,13 +191,12 @@ void CxxAstVisitorComponentIndexer::visitClassTemplateSpecializationDecl(clang::
 {
 	if (getAstVisitor()->shouldVisitDecl(d))
 	{
-		clang::NamedDecl* specializedFromDecl = nullptr;
+		clang::CXXRecordDecl* specializedFromDecl = nullptr;
 
-		// todo: use context and childcontext!!
 		llvm::PointerUnion<clang::ClassTemplateDecl*, clang::ClassTemplatePartialSpecializationDecl*> pu = d->getSpecializedTemplateOrPartial();
 		if (pu.is<clang::ClassTemplateDecl*>())
 		{
-			specializedFromDecl = pu.get<clang::ClassTemplateDecl*>();
+			specializedFromDecl = pu.get<clang::ClassTemplateDecl*>()->getTemplatedDecl();
 		}
 		else if (pu.is<clang::ClassTemplatePartialSpecializationDecl*>())
 		{
@@ -330,14 +329,49 @@ void CxxAstVisitorComponentIndexer::visitFunctionDecl(clang::FunctionDecl* d)
 
 		if (d->isFunctionTemplateSpecialization())
 		{
-			Id templateId = getOrCreateSymbolId(d->getPrimaryTemplate()->getTemplatedDecl());
-			m_client->recordSymbolKind(templateId, SYMBOL_FUNCTION);
-			m_client->recordReference(
-				REFERENCE_TEMPLATE_SPECIALIZATION,
-				templateId,
-				symbolId,
-				getParseLocation(d->getLocation())
-			);
+			if (clang::isa<clang::ClassTemplateSpecializationDecl>(d->getParent()) &&
+				!clang::isa<clang::ClassTemplatePartialSpecializationDecl>(d->getParent()) &&
+				!clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(d->getParent())->isExplicitSpecialization())
+			{
+				// record edge from Foo<int>::bar<float>() to Foo<T>::bar<U>() instead of recording an edge from Foo<int>::bar<float>() to Foo<int>::bar<U>()
+				// because there is not "written" code for Foo<int>::bar<U>() if Foo<int> is an implicit template specialization.
+				if (clang::CXXRecordDecl* declaringRecordDecl = clang::dyn_cast_or_null<clang::CXXRecordDecl>(d->getParent()))
+				{
+					if (clang::CXXRecordDecl* declaringRecordTemplateDecl = declaringRecordDecl->getTemplateInstantiationPattern())
+					{
+						for (clang::Decl* templateMethodDecl : declaringRecordTemplateDecl->decls())
+						{
+							if (clang::FunctionTemplateDecl* functionTemplateDecl = clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(templateMethodDecl))
+							{
+								if (d->getName() == functionTemplateDecl->getName())
+								{
+									Id templateMethodId = getOrCreateSymbolId(functionTemplateDecl);
+									m_client->recordSymbolKind(templateMethodId, SYMBOL_METHOD);
+									m_client->recordReference(
+										REFERENCE_TEMPLATE_SPECIALIZATION,
+										templateMethodId,
+										symbolId,
+										getParseLocation(d->getLocation())
+									);
+									break;
+								}
+							}
+						}
+					}
+				}
+			}
+			else
+			{
+				// record edge from foo<int>() to foo<T>()
+				Id templateId = getOrCreateSymbolId(d->getPrimaryTemplate()->getTemplatedDecl());
+				m_client->recordSymbolKind(templateId, SYMBOL_FUNCTION);
+				m_client->recordReference(
+					REFERENCE_TEMPLATE_SPECIALIZATION,
+					templateId,
+					symbolId,
+					getParseLocation(d->getLocation())
+				);
+			}
 		}
 	}
 }
@@ -363,6 +397,7 @@ void CxxAstVisitorComponentIndexer::visitCXXMethodDecl(clang::CXXMethodDecl* d)
 			);
 		}
 
+		// record edge from Foo::bar<int>() to Foo::bar<T>()
 		recordTemplateMemberSpecialization(
 			d->getMemberSpecializationInfo(),
 			symbolId,
diff --git a/src/test/CxxParserTestSuite.h b/src/test/CxxParserTestSuite.h
index e953756e..d228bdd6 100644
--- a/src/test/CxxParserTestSuite.h
+++ b/src/test/CxxParserTestSuite.h
@@ -15,8 +15,35 @@
 class CxxParserTestSuite: public CxxTest::TestSuite
 {
 public:
+	void test_cxx_parser_skips_implicit_template_method_definition_of_implicit_template_class_instantiation()
+	{
+		std::shared_ptr<TestIntermediateStorage> client = parseCode(
+			"template <typename T>\n"
+			"class A\n"
+			"{\n"
+			"public:\n"
+			"	template <typename U>\n"
+			"	void foo() {}\n"
+			"};\n"
+			"\n"
+			"int main()\n"
+			"{\n"
+			"	A<int>().foo<float>();\n"
+			"	return 0;\n"
+			"}\n"
+		);
 
-	void test_foofooofooofow()
+		TS_ASSERT( /*NOT!*/ !utility::containsElement<std::wstring>(
+			client->methods, L"public void A<int>::foo<typename U>() <6:2 <6:7 6:9> 6:14>"
+		));
+		TS_ASSERT(utility::containsElement<std::wstring>(
+			client->templateSpecializations, L"void A<int>::foo<float>() -> void A<typename T>::foo<typename U>() <6:7 6:9>"
+		));
+	}
+
+
+
+	void test_foofooofooofow1()
 	{
 		{
 			std::shared_ptr<TestIntermediateStorage> client = parseCode(