pahole tile.cpp.o .c

die__process_class: tag not supported 0x2f (template_type_parameter)!
dwarf_expr: unhandled 0x12 DW_OP_ operation
dwarf_expr: unhandled 0x12 DW_OP_ operation
dwarf_expr: unhandled 0x12 DW_OP_ operation
dwarf_expr: unhandled 0x12 DW_OP_ operation
dwarf_expr: unhandled 0x12 DW_OP_ operation
dwarf_expr: unhandled 0x12 DW_OP_ operation
die__process_function: tag not supported 0x4107 (GNU_template_parameter_pack)!
die__process_class: tag not supported 0x30 (template_value_parameter)!
die__process_class: tag not supported 0x4106 (GNU_template_template_param)!
die__process_function: tag not supported 0x4108 (GNU_formal_parameter_pack)!
ftype__recode_dwarf_types: couldn't find 0x501da abstract_origin for 0x50231 (formal_parameter)!
struct _IO_FILE {
	int                        _flags;               /*     0     4 */

	/* XXX 4 bytes hole, try to pack */

	char *                     _IO_read_ptr;         /*     8     8 */
	char *                     _IO_read_end;         /*    16     8 */
	char *                     _IO_read_base;        /*    24     8 */
	char *                     _IO_write_base;       /*    32     8 */
	char *                     _IO_write_ptr;        /*    40     8 */
	char *                     _IO_write_end;        /*    48     8 */
	char *                     _IO_buf_base;         /*    56     8 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	char *                     _IO_buf_end;          /*    64     8 */
	char *                     _IO_save_base;        /*    72     8 */
	char *                     _IO_backup_base;      /*    80     8 */
	char *                     _IO_save_end;         /*    88     8 */
	class _IO_marker *         _markers;             /*    96     8 */
	class _IO_FILE *           _chain;               /*   104     8 */
	int                        _fileno;              /*   112     4 */
	int                        _flags2;              /*   116     4 */
	__off_t                    _old_offset;          /*   120     8 */
	/* --- cacheline 2 boundary (128 bytes) --- */
	short unsigned int         _cur_column;          /*   128     2 */
	signed char                _vtable_offset;       /*   130     1 */
	char                       _shortbuf[1];         /*   131     1 */

	/* XXX 4 bytes hole, try to pack */

	_IO_lock_t *               _lock;                /*   136     8 */
	__off64_t                  _offset;              /*   144     8 */
	void *                     __pad1;               /*   152     8 */
	void *                     __pad2;               /*   160     8 */
	void *                     __pad3;               /*   168     8 */
	void *                     __pad4;               /*   176     8 */
	size_t                     __pad5;               /*   184     8 */
	/* --- cacheline 3 boundary (192 bytes) --- */
	int                        _mode;                /*   192     4 */
	char                       _unused2[20];         /*   196    20 */

	/* size: 216, cachelines: 4, members: 29 */
	/* sum members: 208, holes: 2, sum holes: 8 */
	/* last cacheline: 24 bytes */
};
struct typedef __va_list_tag __va_list_tag {
	unsigned int               gp_offset;            /*     0     4 */
	unsigned int               fp_offset;            /*     4     4 */
	void *                     overflow_arg_area;    /*     8     8 */
	void *                     reg_save_area;        /*    16     8 */

	/* size: 24, cachelines: 1, members: 4 */
	/* last cacheline: 24 bytes */
};
struct _IO_marker {
	class _IO_marker *         _next;                /*     0     8 */
	class _IO_FILE *           _sbuf;                /*     8     8 */
	int                        _pos;                 /*    16     4 */

	/* size: 24, cachelines: 1, members: 3 */
	/* padding: 4 */
	/* last cacheline: 24 bytes */
};
struct __pthread_internal_list {
	class __pthread_internal_list * __prev;          /*     0     8 */
	class __pthread_internal_list * __next;          /*     8     8 */

	/* size: 16, cachelines: 1, members: 2 */
	/* last cacheline: 16 bytes */
};
struct tm {
	int                        tm_sec;               /*     0     4 */
	int                        tm_min;               /*     4     4 */
	int                        tm_hour;              /*     8     4 */
	int                        tm_mday;              /*    12     4 */
	int                        tm_mon;               /*    16     4 */
	int                        tm_year;              /*    20     4 */
	int                        tm_wday;              /*    24     4 */
	int                        tm_yday;              /*    28     4 */
	int                        tm_isdst;             /*    32     4 */

	/* XXX 4 bytes hole, try to pack */

	long int                   tm_gmtoff;            /*    40     8 */
	const char  *              tm_zone;              /*    48     8 */

	/* size: 56, cachelines: 1, members: 11 */
	/* sum members: 52, holes: 1, sum holes: 4 */
	/* last cacheline: 56 bytes */
};
struct lconv {
	char *                     decimal_point;        /*     0     8 */
	char *                     thousands_sep;        /*     8     8 */
	char *                     grouping;             /*    16     8 */
	char *                     int_curr_symbol;      /*    24     8 */
	char *                     currency_symbol;      /*    32     8 */
	char *                     mon_decimal_point;    /*    40     8 */
	char *                     mon_thousands_sep;    /*    48     8 */
	char *                     mon_grouping;         /*    56     8 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	char *                     positive_sign;        /*    64     8 */
	char *                     negative_sign;        /*    72     8 */
	char                       int_frac_digits;      /*    80     1 */
	char                       frac_digits;          /*    81     1 */
	char                       p_cs_precedes;        /*    82     1 */
	char                       p_sep_by_space;       /*    83     1 */
	char                       n_cs_precedes;        /*    84     1 */
	char                       n_sep_by_space;       /*    85     1 */
	char                       p_sign_posn;          /*    86     1 */
	char                       n_sign_posn;          /*    87     1 */
	char                       int_p_cs_precedes;    /*    88     1 */
	char                       int_p_sep_by_space;   /*    89     1 */
	char                       int_n_cs_precedes;    /*    90     1 */
	char                       int_n_sep_by_space;   /*    91     1 */
	char                       int_p_sign_posn;      /*    92     1 */
	char                       int_n_sign_posn;      /*    93     1 */

	/* size: 96, cachelines: 2, members: 24 */
	/* padding: 2 */
	/* last cacheline: 32 bytes */
};
struct TextureFromMeshParams {
	class IMesh *              mesh;                 /*     0     8 */
	class dimension2d<unsigned int> dim;             /*     8     8 */
	string                     rtt_texture_name;     /*    16    32 */
	bool                       delete_texture_on_shutdown; /*    48     1 */

	/* XXX 3 bytes hole, try to pack */

	v3f                        camera_position;      /*    52    12 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	v3f                        camera_lookat;        /*    64    12 */
	class CMatrix4<float>     camera_projection_matrix; /*    76    64 */
	/* --- cacheline 2 boundary (128 bytes) was 12 bytes ago --- */
	class SColorf             ambient_light;         /*   140    16 */
	v3f                        light_position;       /*   156    12 */
	class SColorf             light_color;           /*   168    16 */
	f32                        light_radius;         /*   184     4 */
	void ~TextureFromMeshParams(class TextureFromMeshParams *, int);

	void TextureFromMeshParams(class TextureFromMeshParams *);


	/* size: 192, cachelines: 3, members: 11 */
	/* sum members: 185, holes: 1, sum holes: 3 */
	/* padding: 4 */
};
struct FlagDesc {
	const char  *              name;                 /*     0     8 */
	u32                        flag;                 /*     8     4 */

	/* size: 16, cachelines: 1, members: 2 */
	/* padding: 4 */
	/* last cacheline: 16 bytes */
};
class Semaphore {
	sem_t                      semaphore;            /*     0    32 */
public:

	void Semaphore(class Semaphore *, int);

	void ~Semaphore(class Semaphore *, int);

	void post(class Semaphore *, unsigned int);

	void wait(class Semaphore *);

	bool wait(class Semaphore *, unsigned int);

	void Semaphore(class Semaphore *, const class Semaphore  &);

	class Semaphore & operator=(class Semaphore *, const class Semaphore  &);


	/* size: 32, cachelines: 1, members: 1 */
	/* last cacheline: 32 bytes */
};
class ILogOutput {
public:

	int ()(void) * *           _vptr.ILogOutput;     /*     0     8 */
	void ~ILogOutput(class ILogOutput *, int);

	void ILogOutput(class ILogOutput *, );

	void ILogOutput(class ILogOutput *, const class ILogOutput  &);

	void ILogOutput(class ILogOutput *);

	virtual void logRaw(class ILogOutput *, enum LogLevel, const string  &);

	virtual void log(class ILogOutput *, enum LogLevel, const string  &, const string  &, const string  &, const string  &);

	/* vtable has 2 entries: {
	   [0] = logRaw((null)), 
	   [1] = log((null)), 
	} */
	/* size: 8, cachelines: 1, members: 1 */
	/* last cacheline: 8 bytes */
};
class Logger {
	class vector<ILogOutput*, std::allocator<ILogOutput*> > m_outputs[6]; /*     0   144 */
	/* --- cacheline 2 boundary (128 bytes) was 16 bytes ago --- */
	volatile volatile bool     m_silenced_levels;    /*   144     6 */

	/* XXX 2 bytes hole, try to pack */

	class map<std::thread::id, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::thread::id>, std::allocator<std::pair<const std::thread::id, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > m_thread_names; /*   152    48 */
	/* --- cacheline 3 boundary (192 bytes) was 8 bytes ago --- */
	Mutex                      m_mutex;              /*   200    40 */
	bool                       m_trace_enabled;      /*   240     1 */
public:

	void addOutput(class Logger *, class ILogOutput *);

	void addOutput(class Logger *, class ILogOutput *, enum LogLevel);

	void addOutputMasked(class Logger *, class ILogOutput *, LogLevelMask);

	void addOutputMaxLevel(class Logger *, class ILogOutput *, enum LogLevel);

	LogLevelMask removeOutput(class Logger *, class ILogOutput *);

	void setLevelSilenced(class Logger *, enum LogLevel, bool);

	void registerThread(class Logger *, const string  &);

	void deregisterThread(class Logger *);

	void log(class Logger *, enum LogLevel, const string  &);

	void logRaw(class Logger *, enum LogLevel, const string  &);

	void setTraceEnabled(class Logger *, bool);

	bool getTraceEnabled(class Logger *);

	enum LogLevel stringToLevel(const string  &);

	stringconst getLevelLabel(enum LogLevel);

	void logToOutputsRaw(class Logger *, enum LogLevel, const string  &);

	void logToOutputs(class Logger *, enum LogLevel, const string  &, const string  &, const string  &, const string  &);

	stringconst getThreadName(class Logger *);


	/* size: 248, cachelines: 4, members: 5 */
	/* sum members: 239, holes: 1, sum holes: 2 */
	/* padding: 7 */
	/* last cacheline: 56 bytes */
};
class StreamLogOutput : public ICombinedLogOutput {
public:

	/* class ICombinedLogOutput  <ancestor>; */      /*     0     8 */
	ostream &const             m_stream;             /*     8     8 */
	void StreamLogOutput(class StreamLogOutput *, ostream &);

	virtual void logRaw(class StreamLogOutput *, enum LogLevel, const string  &);

	/* vtable has 1 entries: {
	   [0] = logRaw((null)), 
	} */
	/* size: 16, cachelines: 1, members: 2 */
	/* last cacheline: 16 bytes */

	/* BRAIN FART ALERT! 16 != 8 + 0(holes), diff = 8 */

};
struct timezone {
	int                        tz_minuteswest;       /*     0     4 */
	int                        tz_dsttime;           /*     4     4 */

	/* size: 8, cachelines: 1, members: 2 */
	/* last cacheline: 8 bytes */
};
class Settings {
	SettingEntries             m_settings;           /*     0    56 */
	SettingEntries             m_defaults;           /*    56    56 */
	/* --- cacheline 1 boundary (64 bytes) was 48 bytes ago --- */
	SettingsCallbackMap        m_callbacks;          /*   112    56 */
	/* --- cacheline 2 boundary (128 bytes) was 40 bytes ago --- */
	Mutex                      m_callback_mutex;     /*   168    40 */
	/* --- cacheline 3 boundary (192 bytes) was 16 bytes ago --- */
	Mutex                      m_mutex;              /*   208    40 */
public:

	void Settings(class Settings *);

	void ~Settings(class Settings *, int);

	class Settings & operator+=(class Settings *, const class Settings  &);

	class Settings & operator=(class Settings *, const class Settings  &);

	bool readConfigFile(class Settings *, const char  *);

	bool updateConfigFile(class Settings *, const char  *);

	bool parseCommandLine(class Settings *, int, char * *, class map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, ValueSpec, std::less<std::__cxx11::b);

	bool parseConfigLines(class Settings *, istream &, const string  &);

	void writeLines(const class Settings  *, ostream &, u32);

	enum SettingsParseEvent parseConfigObject(class Settings *, const string  &, const string  &, string &, string &);

	bool updateConfigObject(class Settings *, istream &, ostream &, const string  &, u32);

	bool checkNameValid(const string  &);

	bool checkValueValid(const string  &);

	string getMultiline(istream &, size_t *);

	void printEntry(ostream &, const string  &, const class SettingsEntry  &, u32);

	const class SettingsEntry  & getEntry(const class Settings  *, const string  &);

	class Settings * getGroup(const class Settings  *, const string  &);

	const string  & get(const class Settings  *, const string  &);

	bool getBool(const class Settings  *, const string  &);

	u16 getU16(const class Settings  *, const string  &);

	s16 getS16(const class Settings  *, const string  &);

	s32 getS32(const class Settings  *, const string  &);

	u64 getU64(const class Settings  *, const string  &);

	float getFloat(const class Settings  *, const string  &);

	v2f getV2F(const class Settings  *, const string  &);

	v3f getV3F(const class Settings  *, const string  &);

	u32 getFlagStr(const class Settings  *, const string  &, const class FlagDesc  *, u32 *);

	bool getStruct(const class Settings  *, const string  &, const string  &, void *, size_t);

	bool getNoiseParams(const class Settings  *, const string  &, class NoiseParams &);

	bool getNoiseParamsFromValue(const class Settings  *, const string  &, class NoiseParams &);

	bool getNoiseParamsFromGroup(const class Settings  *, const string  &, class NoiseParams &);

	class vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basi getNames(const class Settings  *);

	bool exists(const class Settings  *, const string  &);

	bool getEntryNoEx(const class Settings  *, const string  &, class SettingsEntry &);

	bool getGroupNoEx(const class Settings  *, const string  &, class Settings * &);

	bool getNoEx(const class Settings  *, const string  &, string &);

	bool getFlag(const class Settings  *, const string  &);

	bool getU16NoEx(const class Settings  *, const string  &, u16 &);

	bool getS16NoEx(const class Settings  *, const string  &, s16 &);

	bool getS32NoEx(const class Settings  *, const string  &, s32 &);

	bool getU64NoEx(const class Settings  *, const string  &, u64 &);

	bool getFloatNoEx(const class Settings  *, const string  &, float &);

	bool getV2FNoEx(const class Settings  *, const string  &, v2f &);

	bool getV3FNoEx(const class Settings  *, const string  &, v3f &);

	bool getFlagStrNoEx(const class Settings  *, const string  &, u32 &, class FlagDesc *);

	bool setEntry(class Settings *, const string  &, const void  *, bool, bool);

	bool set(class Settings *, const string  &, const string  &);

	bool setDefault(class Settings *, const string  &, const string  &);

	bool setGroup(class Settings *, const string  &, class Settings *);

	bool setGroupDefault(class Settings *, const string  &, class Settings *);

	bool setBool(class Settings *, const string  &, bool);

	bool setS16(class Settings *, const string  &, s16);

	bool setU16(class Settings *, const string  &, u16);

	bool setS32(class Settings *, const string  &, s32);

	bool setU64(class Settings *, const string  &, u64);

	bool setFloat(class Settings *, const string  &, float);

	bool setV2F(class Settings *, const string  &, v2f);

	bool setV3F(class Settings *, const string  &, v3f);

	bool setFlagStr(class Settings *, const string  &, u32, const class FlagDesc  *, u32);

	bool setNoiseParams(class Settings *, const string  &, const class NoiseParams  &, bool);

	bool setStruct(class Settings *, const string  &, const string  &, void *);

	bool remove(class Settings *, const string  &);

	void clear(class Settings *);

	void clearDefaults(class Settings *);

	void updateValue(class Settings *, const class Settings  &, const string  &);

	void update(class Settings *, const class Settings  &);

	void registerChangedCallback(class Settings *, const string  &, SettingsChangedCallback, void *);

	void deregisterChangedCallback(class Settings *, const string  &, SettingsChangedCallback, void *);

	void updateNoLock(class Settings *, const class Settings  &);

	void clearNoLock(class Settings *);

	void clearDefaultsNoLock(class Settings *);

	void doCallbacks(const class Settings  *, const string  &);


	/* size: 248, cachelines: 4, members: 5 */
	/* last cacheline: 56 bytes */
};
struct SettingsEntry {
	string                     value;                /*     0    32 */
	class Settings *           group;                /*    32     8 */
	bool                       is_group;             /*    40     1 */
	void SettingsEntry(class SettingsEntry *);

	void SettingsEntry(class SettingsEntry *, const string  &);

	void SettingsEntry(class SettingsEntry *, class Settings *);


	/* size: 48, cachelines: 1, members: 3 */
	/* padding: 7 */
	/* last cacheline: 48 bytes */
};
class ITextureSource : public ISimpleTextureSource {
public:

	/* class ISimpleTextureSource <ancestor>; */     /*     0     8 */
	void ITextureSource(class ITextureSource *, const class ITextureSource  &);

	void ITextureSource(class ITextureSource *);

	virtual void ~ITextureSource(class ITextureSource *, int);

	virtual u32 getTextureId(class ITextureSource *, const string  &);

	virtual string getTextureName(class ITextureSource *, u32);

	virtual class ITexture * getTexture(class ITextureSource *, u32);

	virtual class ITexture * getTexture(class ITextureSource *, const string  &, u32 *);

	virtual class ITexture * getTextureForMesh(class ITextureSource *, const string  &, u32 *);

	virtual Palette * getPalette(class ITextureSource *, const string  &);

	virtual class IrrlichtDevice * getDevice(class ITextureSource *);

	virtual bool isKnownSourceImage(class ITextureSource *, const string  &);

	virtual class ITexture * generateTextureFromMesh(class ITextureSource *, const class TextureFromMeshParams  &);

	virtual class ITexture * getNormalTexture(class ITextureSource *, const string  &);

	virtual class SColor getTextureAverageColor(class ITextureSource *, const string  &);

	virtual class ITexture * getShaderFlagsTexture(class ITextureSource *, bool);

	/* vtable has 12 entries: {
	   [3] = getTextureId((null)), 
	   [4] = getTextureName((null)), 
	   [5] = getTexture((null)), 
	   [2] = getTexture((null)), 
	   [6] = getTextureForMesh((null)), 
	   [7] = getPalette((null)), 
	   [8] = getDevice((null)), 
	   [9] = isKnownSourceImage((null)), 
	   [10] = generateTextureFromMesh((null)), 
	   [11] = getNormalTexture((null)), 
	   [12] = getTextureAverageColor((null)), 
	   [13] = getShaderFlagsTexture((null)), 
	} */
	/* size: 8, cachelines: 1, members: 1 */
	/* last cacheline: 8 bytes */

	/* BRAIN FART ALERT! 8 != 0 + 0(holes), diff = 8 */

};
class BasicStrfnd<char> {
	typedef struct basic_string<char, std::char_traits<char>, std::allocator<char> > String;

	/* tag__fprintf: const_type tag not supported! */;

	String                     str;                  /*     0    32 */
	size_t                     pos;                  /*    32     8 */
public:

	void BasicStrfnd(class BasicStrfnd<char> *, const String  &);

	void start(class BasicStrfnd<char> *, const String  &);

	size_t where(class BasicStrfnd<char> *);

	void to(class BasicStrfnd<char> *, size_t);

	bool at_end(class BasicStrfnd<char> *);

	String what(class BasicStrfnd<char> *);

	String next(class BasicStrfnd<char> *, const String  &);

	String next_esc(class BasicStrfnd<char> *, const String  &, char);

	void skip_over(class BasicStrfnd<char> *, const String  &);

	void ~BasicStrfnd(class BasicStrfnd<char> *, int);


	/* size: 40, cachelines: 1, members: 2 */
	/* last cacheline: 40 bytes */
};
class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > {
	class map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > m_values; /*     0    48 */
	Mutex                      m_mutex;              /*    48    40 */
public:

	void MutexedMap(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<ch);

	void set(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<ch, const class basic_string<char, std::char_traits<char>, std::allocator<char> >  &, const class basic_string<char, std::char_traits<char>, std::allocator<char> >  &);

	bool get(const class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_str, const class basic_string<char, std::char_traits<char>, std::allocator<char> >  &, class basic_string<char, std::char_traits<char>, std::allocator<char> > *);

	class vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basi getValues(const class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_str);

	void clear(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<ch);

	void ~MutexedMap(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<ch, int);


	/* size: 88, cachelines: 2, members: 2 */
	/* last cacheline: 24 bytes */
};
struct TextureInfo {
	string                     name;                 /*     0    32 */
	class ITexture *           texture;              /*    32     8 */
	void TextureInfo(class TextureInfo *, const string  &, class ITexture *);

	void TextureInfo(class TextureInfo *, );

	void TextureInfo(class TextureInfo *, const class TextureInfo  &);

	void ~TextureInfo(class TextureInfo *, int);


	/* size: 40, cachelines: 1, members: 2 */
	/* last cacheline: 40 bytes */
};
class SourceImageCache {
	class map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, irr::video::IImage*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, irr::video::IImage*> > > m_images; /*     0    48 */
public:

	void ~SourceImageCache(class SourceImageCache *, int);

	void insert(class SourceImageCache *, const string  &, class IImage *, bool, class IVideoDriver *);

	class IImage * get(class SourceImageCache *, const string  &);

	class IImage * getOrLoad(class SourceImageCache *, const string  &, class IrrlichtDevice *);

	void SourceImageCache(class SourceImageCache *);


	/* size: 48, cachelines: 1, members: 1 */
	/* last cacheline: 48 bytes */
};
class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> {
	class map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> > > m_values; /*     0    48 */
	Mutex                      m_mutex;              /*    48    40 */
public:

	void MutexedMap(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> *);

	void set(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> *, const class basic_string<char, std::char_traits<char>, std::allocator<char> >  &, const bool  &);

	bool get(const class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>  *, const class basic_string<char, std::char_traits<char>, std::allocator<char> >  &, bool *);

	class vector<bool, std::allocator<bool> > getValues(const class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>  *);

	void clear(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> *);

	void ~MutexedMap(class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> *, int);


	/* size: 88, cachelines: 2, members: 2 */
	/* last cacheline: 24 bytes */
};
class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> {
public:

	class basic_string<char, std::char_traits<char>, std::allocator<char> > key; /*     0    32 */
	class list<CallerInfo<unsigned char, unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int>, std::allocator<CallerInfo<unsigned char, unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> > > callers; /*    32    24 */
	void GetRequest(class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, );

	void ~GetRequest(class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, , int);

	void GetRequest(class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, , class basic_string<char, std::char_traits<char>, std::allocator<char> >);

	void GetRequest(class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, , const class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned );


	/* size: 56, cachelines: 1, members: 2 */
	/* last cacheline: 56 bytes */
};
class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > {
protected:

	class deque<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char>, std::allocator<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > > m_queue; /*     0    80 */
	/* --- cacheline 1 boundary (64 bytes) was 16 bytes ago --- */
	Mutex                      m_mutex;              /*    80    40 */
	class Semaphore           m_signal;              /*   120    32 */
public:

	void MutexedQueue(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un);

	bool empty(const class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned i);

	void push_back(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, );

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_frontNoEx(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, u32);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_front(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, u32);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_frontNoEx(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_back(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, u32);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_backNoEx(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, u32);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop_backNoEx(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un);

protected:

	Mutex & getMutex(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un);

	class deque<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned  getQueue(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un);

public:

	void ~MutexedQueue(class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, un, int);


	/* size: 152, cachelines: 3, members: 3 */
	/* last cacheline: 24 bytes */
};
class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> {
	class MutexedQueue<GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > m_queue; /*     0   152 */
public:

	bool empty(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char);

	void add(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, class basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned char, unsigned char, class ResultQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned int);

	class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,  pop(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char);

	void pushResult(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, class GetRequest<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, , unsigned int);

	void ~RequestQueue(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, int);

	void RequestQueue(class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char);


	/* size: 152, cachelines: 3, members: 1 */
	/* last cacheline: 24 bytes */
};
class ResultQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> : public MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > {
public:

	/* class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > <ancestor>; */ /*     0   152 */
	void ~ResultQueue(class ResultQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,, int);

	void ResultQueue(class ResultQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char,);


	/* size: 152, cachelines: 3, members: 1 */
	/* last cacheline: 24 bytes */

	/* BRAIN FART ALERT! 152 != 0 + 0(holes), diff = 152 */

};
class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> {
public:

	class basic_string<char, std::char_traits<char>, std::allocator<char> > key; /*     0    32 */
	unsigned int               item;                 /*    32     4 */
	struct pair<unsigned char, unsigned char> caller; /*    36     2 */
	void GetResult(class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u);

	void GetResult(class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u, const class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned c);

	void GetResult(class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u, );

	void ~GetResult(class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u, int);


	/* size: 40, cachelines: 1, members: 3 */
	/* padding: 2 */
	/* last cacheline: 40 bytes */
};
class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > {
protected:

	class deque<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char>, std::allocator<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> > > m_queue; /*     0    80 */
	/* --- cacheline 1 boundary (64 bytes) was 16 bytes ago --- */
	Mutex                      m_mutex;              /*    80    40 */
	class Semaphore           m_signal;              /*   120    32 */
public:

	void MutexedQueue(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns);

	bool empty(const class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned in);

	void push_back(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_frontNoEx(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, u32);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_front(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, u32);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_frontNoEx(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_back(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, u32);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_backNoEx(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, u32);

	class GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, u pop_backNoEx(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns);

protected:

	Mutex & getMutex(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns);

	class deque<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned c getQueue(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns);

public:

	void ~MutexedQueue(class MutexedQueue<GetResult<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, uns, int);


	/* size: 152, cachelines: 3, members: 3 */
	/* last cacheline: 24 bytes */
};
class CallerInfo<unsigned char, unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> {
public:

	unsigned char              caller;               /*     0     1 */
	unsigned char              data;                 /*     1     1 */

	/* XXX 6 bytes hole, try to pack */

	class ResultQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, dest; /*     8     8 */

	/* size: 16, cachelines: 1, members: 3 */
	/* sum members: 10, holes: 1, sum holes: 6 */
	/* last cacheline: 16 bytes */
};
class TextureSource : public IWritableTextureSource {
public:

	/* class IWritableTextureSource <ancestor>; */   /*     0     8 */
	threadid_t                 m_main_thread;        /*     8     8 */
	class IrrlichtDevice *     m_device;             /*    16     8 */
	class SourceImageCache    m_sourcecache;         /*    24    48 */
	/* --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- */
	class MutexedMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool> m_source_image_existence; /*    72    88 */
	/* --- cacheline 2 boundary (128 bytes) was 32 bytes ago --- */
	class vector<TextureInfo, std::allocator<TextureInfo> > m_textureinfo_cache; /*   160    24 */
	class map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> > > m_name_to_id; /*   184    48 */
	/* --- cacheline 3 boundary (192 bytes) was 40 bytes ago --- */
	Mutex                      m_textureinfo_cache_mutex; /*   232    40 */
	/* --- cacheline 4 boundary (256 bytes) was 16 bytes ago --- */
	class RequestQueue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, unsigned char, unsigned char> m_get_texture_queue; /*   272   152 */
	/* --- cacheline 6 boundary (384 bytes) was 40 bytes ago --- */
	class vector<irr::video::ITexture*, std::allocator<irr::video::ITexture*> > m_texture_trash; /*   424    24 */
	/* --- cacheline 7 boundary (448 bytes) --- */
	class unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<irr::video::SColor, std::allocator<irr::video::SColor> >, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<irr::video::SColor, std::allocator<irr::video::SColor> > > > > m_palettes; /*   448    56 */
	bool                       m_setting_trilinear_filter; /*   504     1 */
	bool                       m_setting_bilinear_filter; /*   505     1 */
	bool                       m_setting_anisotropic_filter; /*   506     1 */
	void TextureSource(class TextureSource *, const class TextureSource  &);

	void TextureSource(class TextureSource *, class IrrlichtDevice *);

	virtual void ~TextureSource(class TextureSource *, int);

	virtual u32 getTextureId(class TextureSource *, const string  &);

	virtual string getTextureName(class TextureSource *, u32);

	virtual class ITexture * getTexture(class TextureSource *, u32);

	virtual class ITexture * getTexture(class TextureSource *, const string  &, u32 *);

	virtual class ITexture * getTextureForMesh(class TextureSource *, const string  &, u32 *);

	virtual Palette * getPalette(class TextureSource *, const string  &);

	virtual class IrrlichtDevice * getDevice(class TextureSource *);

	virtual bool isKnownSourceImage(class TextureSource *, const string  &);

	virtual void processQueue(class TextureSource *);

	virtual void insertSourceImage(class TextureSource *, const string  &, class IImage *);

	virtual void rebuildImagesAndTextures(class TextureSource *);

	virtual class ITexture * generateTextureFromMesh(class TextureSource *, const class TextureFromMeshParams  &);

	virtual class ITexture * getNormalTexture(class TextureSource *, const string  &);

	virtual class SColor getTextureAverageColor(class TextureSource *, const string  &);

	virtual class ITexture * getShaderFlagsTexture(class TextureSource *, bool);

	u32 generateTexture(class TextureSource *, const string  &);

	bool generateImagePart(class TextureSource *, string, class IImage * &);

	class IImage * generateImage(class TextureSource *, const string  &);

	/* vtable has 15 entries: {
	   [3] = getTextureId((null)), 
	   [4] = getTextureName((null)), 
	   [5] = getTexture((null)), 
	   [2] = getTexture((null)), 
	   [6] = getTextureForMesh((null)), 
	   [7] = getPalette((null)), 
	   [8] = getDevice((null)), 
	   [9] = isKnownSourceImage((null)), 
	   [14] = processQueue((null)), 
	   [15] = insertSourceImage((null)), 
	   [16] = rebuildImagesAndTextures((null)), 
	   [10] = generateTextureFromMesh((null)), 
	   [11] = getNormalTexture((null)), 
	   [12] = getTextureAverageColor((null)), 
	   [13] = getShaderFlagsTexture((null)), 
	} */
	/* size: 512, cachelines: 8, members: 14 */
	/* padding: 5 */

	/* BRAIN FART ALERT! 512 != 499 + 0(holes), diff = 13 */

};
class IWritableTextureSource : public ITextureSource {
public:

	/* class ITextureSource      <ancestor>; */      /*     0     8 */
	void IWritableTextureSource(class IWritableTextureSource *, const class IWritableTextureSource  &);

	void IWritableTextureSource(class IWritableTextureSource *);

	virtual void ~IWritableTextureSource(class IWritableTextureSource *, int);

	virtual u32 getTextureId(class IWritableTextureSource *, const string  &);

	virtual string getTextureName(class IWritableTextureSource *, u32);

	virtual class ITexture * getTexture(class IWritableTextureSource *, u32);

	virtual class ITexture * getTexture(class IWritableTextureSource *, const string  &, u32 *);

	virtual class IrrlichtDevice * getDevice(class IWritableTextureSource *);

	virtual bool isKnownSourceImage(class IWritableTextureSource *, const string  &);

	virtual class ITexture * generateTextureFromMesh(class IWritableTextureSource *, const class TextureFromMeshParams  &);

	virtual void processQueue(class IWritableTextureSource *);

	virtual void insertSourceImage(class IWritableTextureSource *, const string  &, class IImage *);

	virtual void rebuildImagesAndTextures(class IWritableTextureSource *);

	virtual class ITexture * getNormalTexture(class IWritableTextureSource *, const string  &);

	virtual class SColor getTextureAverageColor(class IWritableTextureSource *, const string  &);

	virtual class ITexture * getShaderFlagsTexture(class IWritableTextureSource *, bool);

	/* vtable has 13 entries: {
	   [3] = getTextureId((null)), 
	   [4] = getTextureName((null)), 
	   [5] = getTexture((null)), 
	   [2] = getTexture((null)), 
	   [8] = getDevice((null)), 
	   [9] = isKnownSourceImage((null)), 
	   [10] = generateTextureFromMesh((null)), 
	   [14] = processQueue((null)), 
	   [15] = insertSourceImage((null)), 
	   [16] = rebuildImagesAndTextures((null)), 
	   [11] = getNormalTexture((null)), 
	   [12] = getTextureAverageColor((null)), 
	   [13] = getShaderFlagsTexture((null)), 
	} */
	/* size: 8, cachelines: 1, members: 1 */
	/* last cacheline: 8 bytes */

	/* BRAIN FART ALERT! 8 != 0 + 0(holes), diff = 8 */

};
class ISimpleTextureSource {
public:

	int ()(void) * *           _vptr.ISimpleTextureSource; /*     0     8 */
	void ISimpleTextureSource(class ISimpleTextureSource *, const class ISimpleTextureSource  &);

	void ISimpleTextureSource(class ISimpleTextureSource *);

	virtual void ~ISimpleTextureSource(class ISimpleTextureSource *, int);

	virtual class ITexture * getTexture(class ISimpleTextureSource *, const string  &, u32 *);

	/* vtable has 1 entries: {
	   [2] = getTexture((null)), 
	} */
	/* size: 8, cachelines: 1, members: 1 */
	/* last cacheline: 8 bytes */
};
class ICombinedLogOutput : public ILogOutput {
public:

	/* class ILogOutput          <ancestor>; */      /*     0     8 */
	void ~ICombinedLogOutput(class ICombinedLogOutput *, int);

	void ICombinedLogOutput(class ICombinedLogOutput *, );

	void ICombinedLogOutput(class ICombinedLogOutput *, const class ICombinedLogOutput  &);

	void ICombinedLogOutput(class ICombinedLogOutput *);

	virtual void log(class ICombinedLogOutput *, enum LogLevel, const string  &, const string  &, const string  &, const string  &);

	/* vtable has 1 entries: {
	   [1] = log((null)), 
	} */
	/* size: 8, cachelines: 1, members: 1 */
	/* last cacheline: 8 bytes */

	/* BRAIN FART ALERT! 8 != 0 + 0(holes), diff = 8 */

};
class BaseException : public exception {
public:

	/* class exception           <ancestor>; */      /*     0     0 */

	/* XXX 8 bytes hole, try to pack */
protected:


	string                     m_s;                  /*     8    32 */
public:

	void BaseException(class BaseException *, const class BaseException  &);

	void BaseException(class BaseException *, const string  &);

	virtual void ~BaseException(class BaseException *, int);

	virtual const char  * what(const class BaseException  *);

	/* vtable has 1 entries: {
	   [2] = what((null)), 
	} */
	/* size: 40, cachelines: 1, members: 2 */
	/* sum members: 32, holes: 1, sum holes: 8 */
	/* last cacheline: 40 bytes */
};
class ItemNotFoundException : public BaseException {
public:

	/* class BaseException       <ancestor>; */      /*     0    40 */
	void ItemNotFoundException(class ItemNotFoundException *, );

	void ItemNotFoundException(class ItemNotFoundException *, const class ItemNotFoundException  &);

	void ItemNotFoundException(class ItemNotFoundException *, const string  &);

	virtual void ~ItemNotFoundException(class ItemNotFoundException *, int);


	/* size: 40, cachelines: 1, members: 1 */
	/* last cacheline: 40 bytes */

	/* BRAIN FART ALERT! 40 != 0 + 0(holes), diff = 40 */

};