// FTTVector - [2020-04-13 11:57:47]
#ifndef _FTTVECTOR_H_
#define _FTTVECTOR_H_

#include "common.h"
#include "memctrl.h"

/*
0021026E FTTVector<CFTTMatrix32>::Reserve(uint)
002104F0 FTTVector<CFTTMatrix32>::~FTTVector()
00210B14 FTTVector<CFTTMatrix32>::Insert(CFTTMatrix32 const&)
00210B36 FTTVector<CFTTMatrix32>::CheckInsert()
00210C5A FTTVector<CFTTMatrix32>::Clear(bool)

001A231A FTTVector<CGfxClothBendConstraint>::Insert(CGfxClothBendConstraint const&)
001A2342 FTTVector<CGfxClothBendConstraint>::Shrink()
001A6840 FTTVector<CGfxClothBendConstraint>::~FTTVector()
001A8EC8 FTTVector<CGfxClothBendConstraint>::CheckInsert()
001A8F80 FTTVector<CGfxClothBendConstraint>::Reserve(uint)

001A2298 FTTVector<CGfxClothStretchConstraint>::Insert(CGfxClothStretchConstraint const&)
001A22BA FTTVector<CGfxClothStretchConstraint>::Shrink()
001A686C FTTVector<CGfxClothStretchConstraint>::~FTTVector()
001A8B02 FTTVector<CGfxClothStretchConstraint>::CheckInsert()
001A8BB6 FTTVector<CGfxClothStretchConstraint>::Reserve(uint)

0019C23E FTTVector<CGfxCrowdFlagPhysics *>::Reserve(uint)
0019C2B6 FTTVector<CGfxCrowdFlagPhysics *>::Insert(CGfxCrowdFlagPhysics *&&)
0019C304 FTTVector<CGfxCrowdFlagPhysics *>::~FTTVector()
001A34B0 FTTVector<CGfxCrowdFlagPhysics *>::FTTVector(FTTVector<CGfxCrowdFlagPhysics *>&&)
001A704E FTTVector<CGfxCrowdFlagPhysics *>::CheckInsert()
001A900A FTTVector<CGfxCrowdFlagPhysics *>::swap(FTTVector<CGfxCrowdFlagPhysics *>&,FTTVector<CGfxCrowdFlagPhysics *>&)

001BCCB0 FTTVector<CGfxPitchLinePatch *>::~FTTVector()
001BCCDC FTTVector<CGfxPitchLinePatch>::~FTTVector()
001BCD58 FTTVector<CGfxPitchLinePatch>::Resize(uint)
001BD4FA FTTVector<CGfxPitchLinePatch *>::Reserve(uint)
001BD572 FTTVector<CGfxPitchLinePatch *>::Insert(CGfxPitchLinePatch *&&)
001BE694 FTTVector<CGfxPitchLinePatch *>::CheckInsert()

00196C28 FTTVector<CStaticAABBTree<ushort,16u>>::~FTTVector()
001970CE FTTVector<CStaticAABBTree<ushort,16u>>::Clear(bool)
0019C83E FTTVector<CStaticAABBTree<ushort,16u>>::Resize(uint)

001A22EE FTTVector<FTTMap<FTTPair<ushort,ushort>,ushort,EdgeLess>::Iterator>::~FTTVector()
001A8D4C FTTVector<FTTMap<FTTPair<ushort,ushort>,ushort,EdgeLess>::Iterator>::Insert(FTTMap<FTTPair<ushort,ushort>,ushort,EdgeLess>::Iterator const&)
001A8DE8 FTTVector<FTTMap<FTTPair<ushort,ushort>,ushort,EdgeLess>::Iterator>::CheckInsert()

002109C8 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::CheckInsert()
00210C92 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Clear(bool)
00210414 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::FTTVector(FTTVector<FTTPair<CFTTBMMMatrixCache::Key,
                                                                                       CFTTBMMMatrixCache::StartCount>> const&)
00210998 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Insert(FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount> const&)
00210824 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator!=(FTTVector<FTTPair<CFTTBMMMatrixCache::Key,
                                                                                                  CFTTBMMMatrixCache::StartCount>>::Iterator const&)
00210830 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator*()
002108C8 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator+(long const&)
00210834 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator++()
0021086C FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator+=(long const&)
00210908 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator-(FTTVector<FTTPair<CFTTBMMMatrixCache::Key,
                                                                                                 CFTTBMMMatrixCache::StartCount>>::Iterator const&)
002108E8 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator-(long const&)
00210890 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator-=(long const&)
00210866 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator->()
002108B8 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator[](long const&)
002103F2 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::operator=(FTTVector<FTTPair<CFTTBMMMatrixCache::Key, CFTTBMMMatrixCache::StartCount>> const&)
0021049A FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::swap(FTTVector<FTTPair<CFTTBMMMatrixCache::Key,
                                                                                          CFTTBMMMatrixCache::StartCount>>&,
                                                                                          FTTVector<FTTPair<CFTTBMMMatrixCache::Key,
                                                                                          CFTTBMMMatrixCache::StartCount>>&)
002104C4 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::~FTTVector()

001A5534 FTTVector<FTTPair<FTTList<TEdgeGroup>::Iterator,TDynamicAABBNode<FTTList<TEdgeGroup>::Iterator> *>>::CheckInsert()
FTTVector<FTTPair<FTTList<TEdgeGroup>::Iterator,TDynamicAABBNode<FTTList<TEdgeGroup>::Iterator> *>>::Insert(FTTPair<FTTList<TEdgeGroup>::Iterator,
001A5508                                                                                                             TDynamicAABBNode<FTTList<TEdgeGroup>::Iterator> *>&&)
0019958E FTTVector<FTTPair<FTTList<TEdgeGroup>::Iterator,TDynamicAABBNode<FTTList<TEdgeGroup>::Iterator> *>>::~FTTVector()

00199960 FTTVector<FTTPair<FTTPair<uint,uint>,FTTPair<uint,uint>>>::Insert(FTTPair<FTTPair<uint,uint>,FTTPair<uint,uint>>&&)
00199AB8 FTTVector<FTTPair<FTTPair<uint,uint>,FTTPair<uint,uint>>>::~FTTVector()
001A6214 FTTVector<FTTPair<FTTPair<uint,uint>,FTTPair<uint,uint>>>::CheckInsert()

001A8542 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::~FTTVector()
001A88C8 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator!=(FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator const&)
001A88D4 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator*()
001A88D8 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator++()
001A88E0 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator->()
001A88E4 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator+=(long const&)
001A8908 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator-=(long const&)
001A8930 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator[](long const&)
001A8940 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator+(long const&)
001A8960 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator-(long const&)
001A8980 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator::operator-(FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Iterator const&)
001A8A2C FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::Insert(FTTPair<FTTPair<ushort,ushort>,ushort> const&)
001A8A52 FTTVector<FTTPair<FTTPair<ushort,ushort>,ushort>>::CheckInsert()

00199B0A FTTVector<FTTPair<TPointF,TPointF>>::Resize(uint)
00199CAC FTTVector<FTTPair<TPointF,TPointF>>::~FTTVector()

001990D8 FTTVector<FTTPair<uint,TDynamicAABBNode<uint> *>>::~FTTVector()
001A4F28 FTTVector<FTTPair<uint,TDynamicAABBNode<uint> *>>::Insert(FTTPair<uint,TDynamicAABBNode<uint> *>&&)
001A4F54 FTTVector<FTTPair<uint,TDynamicAABBNode<uint> *>>::CheckInsert()

00199104 FTTVector<FTTPair<uint,uint>>::Resize(uint)
001991C2 FTTVector<FTTPair<uint,uint>>::Append(FTTVector<FTTPair<uint,uint>> const&)
001995BA FTTVector<FTTPair<uint,uint>>::~FTTVector()
001998AE FTTVector<FTTPair<uint,uint>>::Insert(FTTPair<uint,uint> const&)
001998D0 FTTVector<FTTPair<uint,uint>>::Reserve(uint)
001A5B50 FTTVector<FTTPair<uint,uint>>::swap(FTTVector<FTTPair<uint,uint>>&,FTTVector<FTTPair<uint,uint>>&)
001A5B7A FTTVector<FTTPair<uint,uint>>::operator=(FTTVector<FTTPair<uint,uint>> const&)
001A5B9C FTTVector<FTTPair<uint,uint>>::FTTVector(FTTVector<FTTPair<uint,uint>> const&)
001A5F38 FTTVector<FTTPair<uint,uint>>::Iterator::operator++()
001A5F40 FTTVector<FTTPair<uint,uint>>::Iterator::operator!=(FTTVector<FTTPair<uint,uint>>::Iterator const&)
001A5F4C FTTVector<FTTPair<uint,uint>>::Iterator::operator*()
001A5F50 FTTVector<FTTPair<uint,uint>>::Iterator::operator->()
001A5F54 FTTVector<FTTPair<uint,uint>>::Iterator::operator+=(long const&)
001A5F74 FTTVector<FTTPair<uint,uint>>::Iterator::operator-=(long const&)
001A5F94 FTTVector<FTTPair<uint,uint>>::Iterator::operator[](long const&)
001A5FA0 FTTVector<FTTPair<uint,uint>>::Iterator::operator+(long const&)
001A5FBC FTTVector<FTTPair<uint,uint>>::Iterator::operator-(long const&)
001A5FD8 FTTVector<FTTPair<uint,uint>>::Iterator::operator-(FTTVector<FTTPair<uint,uint>>::Iterator const&)
001A6150 FTTVector<FTTPair<uint,uint>>::CheckInsert()

001B7E5C FTTVector<FTTUPtr<CFTTTexture>>::Resize(uint)
001B7FAC FTTVector<FTTUPtr<CFTTTexture>>::~FTTVector()

00196D22 FTTVector<FTTUPtr<CGfxCrowdCardGroup>>::~FTTVector()
00196F30 FTTVector<FTTUPtr<CGfxCrowdCardGroup>>::Clear(bool)
0019BFC8 FTTVector<FTTUPtr<CGfxCrowdCardGroup>>::Insert(FTTUPtr<CGfxCrowdCardGroup>&&)
001A6D48 FTTVector<FTTUPtr<CGfxCrowdCardGroup>>::CheckInsert()

00196DAA FTTVector<FTTUPtr<CGfxCrowdFlagPhysics>>::~FTTVector()
00196E94 FTTVector<FTTUPtr<CGfxCrowdFlagPhysics>>::Clear(bool)
0019BBAC FTTVector<FTTUPtr<CGfxCrowdFlagPhysics>>::Insert(FTTUPtr<CGfxCrowdFlagPhysics>&&)
001A68C6 FTTVector<FTTUPtr<CGfxCrowdFlagPhysics>>::CheckInsert()

00196D66 FTTVector<FTTUPtr<CGfxCrowdFlagRender>>::~FTTVector()
00196EE2 FTTVector<FTTUPtr<CGfxCrowdFlagRender>>::Clear(bool)
0019C2D0 FTTVector<FTTUPtr<CGfxCrowdFlagRender>>::Insert(FTTUPtr<CGfxCrowdFlagRender>&&)
001A70FA FTTVector<FTTUPtr<CGfxCrowdFlagRender>>::CheckInsert()

0019C0C4 FTTVector<FTTVector<CFTTVector32>>::Resize(uint)
0019C330 FTTVector<FTTVector<CFTTVector32>>::~FTTVector()

0019BDDC FTTVector<FTTVector<bool>>::Resize(uint)
0019C60E FTTVector<FTTVector<bool>>::Clear(bool)
0019CAE2 FTTVector<FTTVector<bool>>::~FTTVector()

0019C3D8 FTTVector<TAABB>::Resize(uint)
0019CAB6 FTTVector<TAABB>::~FTTVector()

00196CB6 FTTVector<TDrawCall>::~FTTVector()
00197096 FTTVector<TDrawCall>::Clear(bool)
001A0F16 FTTVector<TDrawCall>::Insert(TDrawCall const&)
001A82BC FTTVector<TDrawCall>::CheckInsert()

001995F6 FTTVector<TEdgeGroup>::Resize(uint)
00199A1C FTTVector<TEdgeGroup>::Append(FTTVector<TEdgeGroup> const&)
00199A3E FTTVector<TEdgeGroup>::~FTTVector()
001A5C00 FTTVector<TEdgeGroup>::Iterator::operator++()
001A5C08 FTTVector<TEdgeGroup>::Iterator::operator!=(FTTVector<TEdgeGroup>::Iterator const&)
001A5C14 FTTVector<TEdgeGroup>::Iterator::operator*()
001A5C18 FTTVector<TEdgeGroup>::Iterator::operator->()
001A5C1C FTTVector<TEdgeGroup>::Iterator::operator+=(long const&)
001A5C44 FTTVector<TEdgeGroup>::Iterator::operator-=(long const&)
001A5C6C FTTVector<TEdgeGroup>::Iterator::operator[](long const&)
001A5C78 FTTVector<TEdgeGroup>::Iterator::operator+(long const&)
001A5C98 FTTVector<TEdgeGroup>::Iterator::operator-(long const&)
001A5CBC FTTVector<TEdgeGroup>::Iterator::operator-(FTTVector<TEdgeGroup>::Iterator const&)
001A6434 FTTVector<TEdgeGroup>::Insert(TEdgeGroup const&)
001A6456 FTTVector<TEdgeGroup>::CheckInsert()

00196DEE FTTVector<TGfxCardSection>::~FTTVector()
00197026 FTTVector<TGfxCardSection>::Clear(bool)
00199C82 FTTVector<TGfxCardSection>::Insert(TGfxCardSection const&)
00199DF2 FTTVector<TGfxCardSection>::FTTVector(FTTVector<TGfxCardSection>&&)
001A669E FTTVector<TGfxCardSection>::CheckInsert()
001A6786 FTTVector<TGfxCardSection>::swap(FTTVector<TGfxCardSection>&,FTTVector<TGfxCardSection>&)

0019BF28 FTTVector<TGfxCrowdCardHolder>::Reserve(uint)
0019BFA8 FTTVector<TGfxCrowdCardHolder>::Insert(TGfxCrowdCardHolder const&)
0019BFFC FTTVector<TGfxCrowdCardHolder>::~FTTVector()
001A6C94 FTTVector<TGfxCrowdCardHolder>::CheckInsert()

00196E1A FTTVector<TGfxCrowdDynamic>::~FTTVector()
00196FB6 FTTVector<TGfxCrowdDynamic>::Clear(bool)
0019C49C FTTVector<TGfxCrowdDynamic>::Insert(TGfxCrowdDynamic const&)
0019C838 FTTVector<TGfxCrowdDynamic>::Shrink()
001A7396 FTTVector<TGfxCrowdDynamic>::CheckInsert()
001A79C4 FTTVector<TGfxCrowdDynamic>::Reserve(uint)

0019C398 FTTVector<TGfxCrowdQuad>::Iterator::operator->()
0019C39C FTTVector<TGfxCrowdQuad>::Insert(TGfxCrowdQuad const&)
0019C5D6 FTTVector<TGfxCrowdQuad>::Clear(bool)
0019CB30 FTTVector<TGfxCrowdQuad>::~FTTVector()
001A71FC FTTVector<TGfxCrowdQuad>::Iterator::operator++()
001A7204 FTTVector<TGfxCrowdQuad>::Iterator::operator!=(FTTVector<TGfxCrowdQuad>::Iterator const&)
001A7210 FTTVector<TGfxCrowdQuad>::Iterator::operator*()
001A7214 FTTVector<TGfxCrowdQuad>::Iterator::operator+=(long const&)
001A7238 FTTVector<TGfxCrowdQuad>::Iterator::operator-=(long const&)
001A7260 FTTVector<TGfxCrowdQuad>::Iterator::operator[](long const&)
001A7270 FTTVector<TGfxCrowdQuad>::Iterator::operator+(long const&)
001A7290 FTTVector<TGfxCrowdQuad>::Iterator::operator-(long const&)
001A72B0 FTTVector<TGfxCrowdQuad>::Iterator::operator-(FTTVector<TGfxCrowdQuad>::Iterator const&)
001A72BC FTTVector<TGfxCrowdQuad>::CheckInsert()

00196E46 FTTVector<TGfxCrowdSeat>::~FTTVector()
00196F7E FTTVector<TGfxCrowdSeat>::Clear(bool)
00199C5C FTTVector<TGfxCrowdSeat>::Insert(TGfxCrowdSeat const&)
00199DDE FTTVector<TGfxCrowdSeat>::FTTVector(FTTVector<TGfxCrowdSeat>&&)
0019BBE0 FTTVector<TGfxCrowdSeat *>::Reserve(uint)
0019BC58 FTTVector<TGfxCrowdSeat *>::Insert(TGfxCrowdSeat *&&)
0019BCEC FTTVector<TGfxCrowdSeat *>::Resize(uint)
0019BF10 FTTVector<TGfxCrowdSeat *>::Iterator::operator!=(FTTVector<TGfxCrowdSeat *>::Iterator const&)
0019BF1C FTTVector<TGfxCrowdSeat *>::Iterator::operator*()
0019BF20 FTTVector<TGfxCrowdSeat *>::Iterator::operator++()
0019C37E FTTVector<TGfxCrowdSeat *>::Insert(TGfxCrowdSeat * const&)
0019C4C2 FTTVector<TGfxCrowdSeat *>::~FTTVector()
001A65EC FTTVector<TGfxCrowdSeat>::CheckInsert()
001A675C FTTVector<TGfxCrowdSeat>::swap(FTTVector<TGfxCrowdSeat>&,FTTVector<TGfxCrowdSeat>&)
001A69C8 FTTVector<TGfxCrowdSeat *>::CheckInsert()
001A6A74 FTTVector<TGfxCrowdSeat *>::Iterator::operator->()
001A6A78 FTTVector<TGfxCrowdSeat *>::Iterator::operator+=(long const&)
001A6A98 FTTVector<TGfxCrowdSeat *>::Iterator::operator-=(long const&)
001A6AB8 FTTVector<TGfxCrowdSeat *>::Iterator::operator[](long const&)
001A6AC4 FTTVector<TGfxCrowdSeat *>::Iterator::operator+(long const&)
001A6AE0 FTTVector<TGfxCrowdSeat *>::Iterator::operator-(long const&)
001A6AFC FTTVector<TGfxCrowdSeat *>::Iterator::operator-(FTTVector<TGfxCrowdSeat *>::Iterator const&)

00196C76 FTTVector<TGfxCrowdSection>::~FTTVector()
00196FEE FTTVector<TGfxCrowdSection>::Clear(bool)
0019C59E FTTVector<TGfxCrowdSection>::Insert(TGfxCrowdSection const&)
0019C5C0 FTTVector<TGfxCrowdSection>::Shrink()
001A7578 FTTVector<TGfxCrowdSection>::CheckInsert()
001A7680 FTTVector<TGfxCrowdSection>::Reserve(uint)

TPitchLineCircle 0x20
001BCC54 FTTVector<TPitchLineCircle>::~FTTVector()
001BD4C0 FTTVector<TPitchLineCircle>::Clear(bool)
001BD5B2 FTTVector<TPitchLineCircle>::Insert(TPitchLineCircle const&)
001BE850 FTTVector<TPitchLineCircle>::CheckInsert()
001BE992 FTTVector<TPitchLineCircle>::swap(FTTVector<TPitchLineCircle>&,FTTVector<TPitchLineCircle>&)

TPitchLineRect 0x34
001BCC82 FTTVector<TPitchLineRect>::~FTTVector()
001BD486 FTTVector<TPitchLineRect>::Clear(bool)
001BD58C FTTVector<TPitchLineRect>::Insert(TPitchLineRect const&)
001BE740 FTTVector<TPitchLineRect>::CheckInsert()
001BE968 FTTVector<TPitchLineRect>::swap(FTTVector<TPitchLineRect>&,FTTVector<TPitchLineRect>&)

0019F488 FTTVector<TShot>::Resize(uint)
0019F7B6 FTTVector<TShot>::~FTTVector()
001A8016 FTTVector<TShot>::Iterator::operator++()
001A801E FTTVector<TShot>::Iterator::operator!=(FTTVector<TShot>::Iterator const&)
001A802A FTTVector<TShot>::Iterator::operator*()
001A802E FTTVector<TShot>::Iterator::operator->()
001A8034 FTTVector<TShot>::Iterator::operator+=(long const&)
001A8058 FTTVector<TShot>::Iterator::operator-=(long const&)
001A8080 FTTVector<TShot>::Iterator::operator[](long const&)
001A8090 FTTVector<TShot>::Iterator::operator+(long const&)
001A80B0 FTTVector<TShot>::Iterator::operator-(long const&)
001A80D0 FTTVector<TShot>::Iterator::operator-(FTTVector<TShot>::Iterator const&)

001B7DC4 FTTVector<TStem>::Resize(uint)
001B7FF4 FTTVector<TStem>::~FTTVector()

001997A4 FTTVector<bool>::Resize(uint)
00199AE4 FTTVector<bool>::~FTTVector()
001A60BC FTTVector<bool>::Iterator::operator++()
001A60C4 FTTVector<bool>::Iterator::operator!=(FTTVector<bool>::Iterator const&)
001A60D0 FTTVector<bool>::Iterator::operator*()
001A60D4 FTTVector<bool>::Iterator::operator->()
001A60D8 FTTVector<bool>::Iterator::operator+=(long const&)
001A60F4 FTTVector<bool>::Iterator::operator-=(long const&)
001A6110 FTTVector<bool>::Iterator::operator[](long const&)
001A6118 FTTVector<bool>::Iterator::operator+(long const&)
001A6130 FTTVector<bool>::Iterator::operator-(long const&)
001A6148 FTTVector<bool>::Iterator::operator-(FTTVector<bool>::Iterator const&)
001A6C6A FTTVector<bool>::swap(FTTVector<bool>&,FTTVector<bool>&)

00199A8C FTTVector<float>::~FTTVector()
00199980 FTTVector<float>::Reserve(uint)
001999F8 FTTVector<float>::Insert(float const&)
00199A12 FTTVector<float>::Iterator::operator-(FTTVector<float>::Iterator const&)
001A62E6 FTTVector<float>::CheckInsert()

001A6392 FTTVector<float>::Iterator::operator++()
001A639A FTTVector<float>::Iterator::operator!=(FTTVector<float>::Iterator const&)
001A63A6 FTTVector<float>::Iterator::operator*()
001A63AA FTTVector<float>::Iterator::operator->()
001A63B0 FTTVector<float>::Iterator::operator+=(long const&)
001A63D0 FTTVector<float>::Iterator::operator-=(long const&)
001A63F0 FTTVector<float>::Iterator::operator[](long const&)
001A63FC FTTVector<float>::Iterator::operator+(long const&)
001A6418 FTTVector<float>::Iterator::operator-(long const&)

00196CE2 FTTVector<uint>::~FTTVector()
0019705E FTTVector<uint>::Clear(bool)
001A34D8 FTTVector<uint>::Resize(uint)
001A847C FTTVector<uint>::Insert(uint &&)
001A8496 FTTVector<uint>::CheckInsert()

CFTTVector32 0xC
001A34C4 FTTVector<CFTTVector32>::FTTVector(FTTVector<CFTTVector32>&&)
00199D20 FTTVector<CFTTVector32>::~FTTVector()
00198E6C FTTVector<CFTTVector32>::Insert(CFTTVector32 const&)
0019C216 FTTVector<CFTTVector32>::Insert(CFTTVector32&&)
0019C18C FTTVector<CFTTVector32>::Reserve(uint)
0019C666 FTTVector<CFTTVector32>::Clear(bool)
001A5018 FTTVector<CFTTVector32>::CheckInsert()
001A7024 FTTVector<CFTTVector32>::swap(FTTVector<CFTTVector32>&,FTTVector<CFTTVector32>&)

0019C0A4 FTTVector<CFTTVector32>::Iterator::operator+(long const&)
001A6E4A FTTVector<CFTTVector32>::Iterator::operator++()
001A6E52 FTTVector<CFTTVector32>::Iterator::operator!=(FTTVector<CFTTVector32>::Iterator const&)
001A6E5E FTTVector<CFTTVector32>::Iterator::operator*()
001A6E62 FTTVector<CFTTVector32>::Iterator::operator->()
001A6E68 FTTVector<CFTTVector32>::Iterator::operator+=(long const&)
001A6E8C FTTVector<CFTTVector32>::Iterator::operator-=(long const&)
001A6EB4 FTTVector<CFTTVector32>::Iterator::operator[](long const&)
001A6EC4 FTTVector<CFTTVector32>::Iterator::operator-(long const&)
001A6EE4 FTTVector<CFTTVector32>::Iterator::operator-(FTTVector<CFTTVector32>::Iterator const&)

FTTVector_CFTTVector32_Iterator
vptr_FTTVector_CFTTVector32_Iterator

vptr_323634:
  FTTVector<CFTTVector32>::Iterator::operator++(void)
  FTTVector<CFTTVector32>::Iterator::operator!=(FTTVector<CFTTVector32>::Iterator const&)
  FTTVector<CFTTVector32>::Iterator::operator*(void)
  FTTVector<CFTTVector32>::Iterator::operator->(void)
  FTTVector<CFTTVector32>::Iterator::operator+=(long const&)
  FTTVector<CFTTVector32>::Iterator::operator-=(long const&)
  FTTVector<CFTTVector32>::Iterator::operator[](long const&)
  FTTVector<CFTTVector32>::Iterator::operator+(long const&)
  FTTVector<CFTTVector32>::Iterator::operator-(long const&)
  FTTVector<CFTTVector32>::Iterator::operator-(FTTVector<CFTTVector32>::Iterator const&)

FTTVector_float_Iterator

FTTVector_Iterator
*/

template <typename T>
class FTTVector {
public:
  // 001A34C4
  typedef void (*func_FTTVector)(T*);

  FTTVector() {
    //LOGI("FTTVector::FTTVector %p", this);
    list_0 = nullptr;
    func_4 = nullptr;
    total_count_8 = 0;
    use_count_C = 0;
    field_10 = 2.0f;
  }

  // FTTVector(FTTVector<T>& other) {
  //  list_0 = nullptr;
  //  func_4 = nullptr;
  //  total_count_8 = 0;
  //  use_count_C = 0;
  //  swap(other);
  // };

  // 00210414 //^_- 汇编不同，逻辑相同
  FTTVector(FTTVector const& other) {
    this->list_0 = nullptr;
    this->func_4 = other.func_4;
    this->total_count_8 = other.total_count_8;
    this->use_count_C = other.use_count_C;
    this->field_10 = other.field_10;
    if (this->total_count_8 != 0) {  // 00210428
      // 00210432
      this->list_0 = new T[this->total_count_8];
      for (int d_r0 = 0; d_r0 < other.use_count_C; d_r0++) {  // 00210490
        // 0021046A
        this->list_0[d_r0] = other.list_0[d_r0];
      }
    }
  }

  // 002103F2 //^_^
  FTTVector& operator=(FTTVector const& other) {
    FTTVector tmp = other;
    swap(*this, tmp);
    return *this;
  }

  ~FTTVector() {
    // 00199D20
    if (func_4 != nullptr) {
      for (uint dr6 = 0; dr6 < use_count_C; dr6++) {  // loc_199D3A
        // loc_199D2E
        func_4(&list_0[dr6]);
      }
    }
    // loc_199D40
    if (list_0 != nullptr) {
      delete[] list_0;
    }
  };

  class Iterator {
  public:
    Iterator() {
      list_4 = nullptr;
      // unuser_8 = 0;
      // list_C = nullptr;
    };

    // 001A88C8 001A639A
    // 001A639A FTTVector<float>::Iterator::operator!=(FTTVector<float>::Iterator const&)
    virtual bool operator!=(Iterator const& it1) {
      return list_4 != it1.list_4;
    };

    // 001A88D4
    // 001A63A6 FTTVector<float>::Iterator::operator*()
    // 00210830 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator*()
    virtual T* operator*() {
      return list_4;
    };

    // 001A88D8
    // 001A6392 FTTVector<float>::Iterator::operator++()
    // 00210834 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator++()
    virtual void operator++() {
      list_4++;
    };

    // 001A88E0
    // 001A63AA FTTVector<float>::Iterator::operator->()
    // 00210866 FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator->()
    virtual T* operator->() {
      return list_4;
    };

    // 001A88E4
    // 001A63B0 FTTVector<float>::Iterator::operator+=(long const&)
    // 0021086C FTTVector<FTTPair<CFTTBMMMatrixCache::Key,CFTTBMMMatrixCache::StartCount>>::Iterator::operator+=(long const&)
    virtual Iterator operator+=(long const& l2) {
      Iterator it;
      list_4 += l2;
      it.list_4 = list_4;
      return it;
    };

    // 001A8908
    // 001A63D0 FTTVector<float>::Iterator::operator-=(long const&)
    virtual Iterator operator-=(long const& l2) {
      Iterator it;
      list_4 -= l2;
      it.list_4 = list_4;
      return it;
    };

    // 001A8930
    // 001A63F0 FTTVector<float>::Iterator::operator[](long const&)
    virtual T* operator[](long const& l1) {
      return &list_4[l1];
    };

    // 001A8940
    // 001A63FC FTTVector<float>::Iterator::operator+(long const&)
    virtual Iterator operator+(long const& l2) {
      Iterator it;
      it.list_4 = list_4 + l2;
      return it;
    };

    // 001A8960
    // 001A6418 FTTVector<float>::Iterator::operator-(long const&)
    virtual Iterator operator-(long const& l2) {
      Iterator it;
      it.list_4 = list_4 + l2;
      return it;
    };

    // 001A8980
    // 001A6148 FTTVector<bool>::Iterator::operator-(FTTVector<bool>::Iterator const&)
    // 001A5FD8 FTTVector<FTTPair<uint,uint>>::Iterator::operator-(FTTVector<FTTPair<uint,uint>>::Iterator const&)
    virtual int operator-(Iterator const& it) {
      return list_4 - it.list_4;
    };

    T* list_4;
    // int unuser_8;
    // T* list_C;
  };

  // 001A5018
  void CheckInsert() {
    if (total_count_8) {
      //LOGI("CheckInsert: 11 %d %d", total_count_8, use_count_C);
      if (use_count_C == total_count_8) {
        // 001A502A 缓存已经用满，需要扩充结点个数
        int v6 = 0;
        int dr0_new_count = ceilf(field_10 * total_count_8);
        T* pList = new T[dr0_new_count];
        for (uint dr1 = 0; dr1 < total_count_8; dr1++) {  // loc_1A5086
          // loc_1A5072
          memcpy(&pList[dr1], &list_0[dr1], sizeof(T));
          //pList[dr1] = list_0[dr1];
        }

        // 001A508E
        if (list_0 != nullptr) {
          delete[] list_0;
        }
        // loc_1A5096
        list_0 = pList;
        total_count_8 = dr0_new_count;
      }
    } else {
      // loc_1A50BE
      total_count_8 = 1;
      list_0 = new T[total_count_8];
    }
  };

  // 0019705E
  void Clear(bool b) {
    // 0019C66E
    if (func_4 != nullptr) {
      for (uint dr7 = 0; dr7 < use_count_C; dr7++) {
        func_4(&list_0[dr7]);
      }
    }

    // loc_19C688
    if (b) {
      if (list_0) {
        delete[] list_0;
      }
      // loc_19C692
      total_count_8 = 0;
      list_0 = nullptr;
    }
    // loc_19C698
    use_count_C = 0;
  };

  // 00198E6C FTTVector<CFTTVector32>::Insert(CFTTVector32 const&)
  void Insert(T const& aT) {
    CheckInsert();
    memcpy(&list_0[use_count_C], &aT, sizeof(T));
    //list_0[use_count_C] = aT;
    use_count_C++;
  }

  // 0019C216 FTTVector<CFTTVector32>::Insert(CFTTVector32&&)
  void Insert(T&& aT) {
    CheckInsert();
    memcpy(&list_0[use_count_C], &aT, sizeof(T));
    //list_0[use_count_C] = aT;
    use_count_C++;
  };

  // 001A34D8
  void Resize(uint dCount) {
    T* pBuf = new T[dCount];
    memset(pBuf, 0, sizeof(T) * dCount);

    // 001A3508
    if (func_4 != nullptr) {
      for (uint dr5 = dCount; dr5 < use_count_C; dr5++) {
        // loc_1A3510
        func_4(&list_0[dr5]);
      }
    }

    // loc_1A3522
    for (int dr0 = 0; dr0 < dCount; dr0++) {  // loc_1A3538
      // loc_1A3526
      if (dr0 < use_count_C) {
        memcpy(&pBuf[dr0], &list_0[dr0], sizeof(T));
      }
      // loc_1A3536
    }

    // 001A353C
    total_count_8 = dCount;
    use_count_C = dCount;
    if (list_0)
      delete[] list_0;
    list_0 = pBuf;
  };

  // 0019C18C FTTVector<CFTTVector32>::Reserve(uint)
  void Reserve(uint aCount) {
    T* pBuf = new T[aCount];
    if (func_4 != nullptr) {
      for (int dr5 = aCount; dr5 < use_count_C; dr5++) {  // loc_19C1CC
        // loc_19C1C0
        func_4(&list_0[dr5]);
      }
    }

    // loc_19C1D2
    for (int dr1 = 0; dr1 < aCount && dr1 < use_count_C; dr1++) {  // loc_19C1F0
      // loc_19C1D8
      memcpy(&pBuf[dr1], &list_0[dr1], sizeof(T));
    }

    // 0019C1FA
    if (use_count_C >= aCount)
      use_count_C = aCount;
    total_count_8 = aCount;

    // 0019C202
    if (list_0) {
      delete[] list_0;
    }
    list_0 = pBuf;
  };

  // 001A7024
  static void swap(FTTVector<T>& fttvector_r0, FTTVector<T>& fttvector_r1) {
    T* pr2 = fttvector_r0.list_0;
    fttvector_r0.list_0 = fttvector_r1.list_0;
    fttvector_r1.list_0 = pr2;

    func_FTTVector dr2 = fttvector_r0.func_4;
    fttvector_r0.func_4 = fttvector_r1.func_4;
    fttvector_r1.func_4 = dr2;

    int dr2_count = fttvector_r0.total_count_8;
    fttvector_r0.total_count_8 = fttvector_r1.total_count_8;
    fttvector_r1.total_count_8 = dr2_count;

    dr2_count = fttvector_r0.use_count_C;
    fttvector_r0.use_count_C = fttvector_r1.use_count_C;
    fttvector_r1.use_count_C = dr2_count;

    float fr2 = fttvector_r0.field_10;
    fttvector_r0.field_10 = fttvector_r1.field_10;
    fttvector_r1.field_10 = fr2;
  };

  void Shrink() {
    Reserve(use_count_C);
  };

  Iterator End() {
    Iterator ite;
    ite.list_4 = &list_0[use_count_C];
    return ite;
  };

  T* list_0;
  func_FTTVector func_4;  // 00197074 这是个函数指针
  int total_count_8;
  uint use_count_C;
  float field_10;  //默认长度放大系数
};

#endif  //_FTTVECTOR_H_
