#include <wx/wx.h>
#include <wx/accel.h>
#include <wx/accel.h>
#if wxACCESSIBILITY == 1
#include <wx/access.h>
#endif
#include <wx/event.h>
#include <wx/app.h>
#include <wx/archive.h>
#if wxUSE_STL == 1
#include <wx/archive.h>
#endif
#include <wx/archive.h>
#include <wx/archive.h>
#include <wx/arrstr.h>
#include <wx/bitmap.h>
#include <wx/bmpbuttn.h>
#include <wx/dataobj.h>
#include <wx/sizer.h>
#include <wx/brush.h>
#include <wx/gdicmn.h>
#include <wx/dcbuffer.h>
#include <wx/stream.h>
#include <wx/stream.h>
#include <wx/dcbuffer.h>
#include <wx/utils.h>
#include <wx/busyinfo.h>
#include <wx/button.h>
#include <wx/strconv.h>
#include <wx/laywin.h>
#include <wx/calctrl.h>
#include <wx/calctrl.h>
#include <wx/calctrl.h>
#include <wx/caret.h>
#include <wx/checkbox.h>
#include <wx/checklst.h>
#include <wx/choice.h>
#include <wx/choicebk.h>
#include <wx/object.h>
#include <wx/ipc.h>
#include <wx/dcclient.h>
#include <wx/clntdata.h>
#include <wx/clntdata.h>
#include <wx/clipbrd.h>
#include <wx/event.h>
#include <wx/colour.h>
#include <wx/cmndata.h>
#include <wx/gdicmn.h>
#include <wx/colordlg.h>
#include <wx/combobox.h>
#include <wx/event.h>
#include <wx/cmdproc.h>
#include <wx/thread.h>
#include <wx/ipc.h>
#include <wx/cshelp.h>
#include <wx/event.h>
#include <wx/control.h>
#include <wx/ctrlsub.h>
#include <wx/stream.h>
#include <wx/thread.h>
#include <wx/thread.h>
#include <wx/cursor.h>
#include <wx/dataobj.h>
#include <wx/dc.h>
#include <wx/dataobj.h>
#include <wx/datstrm.h>
#include <wx/dataobj.h>
#include <wx/dataobj.h>
#include <wx/datstrm.h>
#include <wx/dateevt.h>
#if wxUSE_DATEPICKCTRL == 1
#include <wx/datectrl.h>
#endif
#include <wx/datetime.h>
#if wxUSE_ODBC == 1
#include <wx/db.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/db.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/db.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/dbgrid.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/db.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/dbtable.h>
#endif
#if wxUSE_ODBC == 1
#include <wx/db.h>
#endif
#if __WXDEBUG__ == 1
#include <wx/memory.h>
#endif
#include <wx/dialup.h>
#include <wx/dialup.h>
#include <wx/dialog.h>
#include <wx/dir.h>
#include <wx/dirdlg.h>
#include <wx/dir.h>
#include <wx/display.h>
#include <wx/docview.h>
#include <wx/docmdi.h>
#include <wx/docmdi.h>
#include <wx/docview.h>
#include <wx/docview.h>
#include <wx/docview.h>
#include <wx/docview.h>
#include <wx/dragimag.h>
#include <wx/event.h>
#include <wx/dnd.h>
#include <wx/dnd.h>
#include <wx/dynlib.h>
#include <wx/dynlib.h>
#include <wx/encconv.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/ffile.h>
#include <wx/wfstream.h>
#include <wx/wfstream.h>
#include <wx/wfstream.h>
#include <wx/filesys.h>
#include <wx/protocol/ftp.h>
#include <wx/file.h>
#include <wx/fileconf.h>
#include <wx/dataobj.h>
#include <wx/filedlg.h>
#include <wx/docview.h>
#include <wx/wfstream.h>
#include <wx/filename.h>
#include <wx/wfstream.h>
#include <wx/wfstream.h>
#include <wx/filesys.h>
#include <wx/stream.h>
#include <wx/fdrepdlg.h>
#include <wx/fdrepdlg.h>
#include <wx/fdrepdlg.h>
#include <wx/sizer.h>
#include <wx/event.h>
#include <wx/font.h>
#include <wx/cmndata.h>
#include <wx/fontdlg.h>
#include <wx/fontenum.h>
#include <wx/gdicmn.h>
#include <wx/fontmap.h>
#include <wx/frame.h>
#include <wx/gbsizer.h>
#include <wx/gbsizer.h>
#include <wx/gbsizer.h>
#include <wx/gdiobj.h>
#if wxUSE_GLCANVAS == 1
#include <wx/glcanvas.h>
#endif
#if wxUSE_GLCANVAS == 1
#include <wx/glcanvas.h>
#endif
#include <wx/gauge.h>
#include <wx/dirctrl.h>
#include <wx/valgen.h>
#include <wx/grid.h>
#include <wx/gbsizer.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/grid.h>
#include <wx/sizer.h>
#include <wx/protocol/http.h>
#include <wx/hash.h>
#include <wx/help.h>
#include <wx/cshelp.h>
#include <wx/event.h>
#include <wx/html/htmlcell.h>
#include <wx/html/htmlcell.h>
#include <wx/html/htmlcell.h>
#include <wx/html/htmprint.h>
#include <wx/html/htmprint.h>
#include <wx/html/helpctrl.h>
#include <wx/html/helpdata.h>
#include <wx/html/helpfrm.h>
#include <wx/html/htmlcell.h>
#include <wx/html/htmlpars.h>
#include <wx/html/htmprint.h>
#include <wx/html/htmltag.h>
#include <wx/html/winpars.h>
#include <wx/html/htmlcell.h>
#include <wx/html/winpars.h>
#include <wx/html/winpars.h>
#include <wx/socket.h>
#include <wx/socket.h>
#include <wx/icon.h>
#include <wx/iconloc.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/image.h>
#include <wx/imaglist.h>
#include <wx/layout.h>
#include <wx/event.h>
#include <wx/joystick.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/laywin.h>
#include <wx/layout.h>
#include <wx/listbox.h>
#include <wx/listctrl.h>
#include <wx/listctrl.h>
#include <wx/listctrl.h>
#include <wx/listctrl.h>
#include <wx/listbook.h>
#include <wx/intl.h>
#include <wx/longlong.h>
#if wxMBFILES == 1
#include <wx/strconv.h>
#endif
#include <wx/strconv.h>
#include <wx/strconv.h>
#include <wx/strconv.h>
#include <wx/strconv.h>
#include <wx/mdi.h>
#include <wx/mdi.h>
#include <wx/mdi.h>
#include <wx/bitmap.h>
#include <wx/event.h>
#include <wx/buffer.h>
#include <wx/dcmemory.h>
#include <wx/fs_mem.h>
#include <wx/mstream.h>
#include <wx/mstream.h>
#include <wx/menu.h>
#include <wx/menu.h>
#include <wx/event.h>
#include <wx/menuitem.h>
#include <wx/msgdlg.h>
#include <wx/mimetype.h>
#include <wx/minifram.h>
#include <wx/dcmirror.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/choicdlg.h>
#include <wx/thread.h>
#include <wx/thread.h>
#include <wx/notebook.h>
#include <wx/notebook.h>
#include <wx/sizer.h>
#include <wx/event.h>
#include <wx/stream.h>
#include <wx/printdlg.h>
#include <wx/cmndata.h>
#include <wx/dcclient.h>
#include <wx/event.h>
#include <wx/palette.h>
#include <wx/panel.h>
#include <wx/textdlg.h>
#include <wx/filefn.h>
#include <wx/pen.h>
#include <wx/gdicmn.h>
#include <wx/dcps.h>
#include <wx/print.h>
#include <wx/print.h>
#include <wx/print.h>
#include <wx/cmndata.h>
#include <wx/printdlg.h>
#include <wx/cmndata.h>
#include <wx/print.h>
#include <wx/print.h>
#include <wx/process.h>
#include <wx/process.h>
#include <wx/progdlg.h>
#include <wx/quantize.h>
#include <wx/laywin.h>
#include <wx/radiobox.h>
#include <wx/radiobut.h>
#include <wx/gdicmn.h>
#include <wx/gdicmn.h>
#include <wx/recguard.h>
#include <wx/regex.h>
#include <wx/region.h>
#include <wx/region.h>
#include <wx/renderer.h>
#include <wx/sashwin.h>
#include <wx/laywin.h>
#include <wx/sashwin.h>
#include <wx/dcscreen.h>
#include <wx/event.h>
#include <wx/event.h>
#include <wx/scrolwin.h>
#include <wx/thread.h>
#include <wx/ipc.h>
#include <wx/event.h>
#include <wx/cshelp.h>
#include <wx/choicdlg.h>
#include <wx/gdicmn.h>
#include <wx/event.h>
#include <wx/sizer.h>
#include <wx/slider.h>
#include <wx/socket.h>
#include <wx/socket.h>
#include <wx/sckstrm.h>
#include <wx/sckstrm.h>
#include <wx/socket.h>
#include <wx/sound.h>
#include <wx/spinbutt.h>
#include <wx/spinctrl.h>
#include <wx/spinbutt.h>
#include <wx/splash.h>
#include <wx/splitter.h>
#include <wx/renderer.h>
#include <wx/splitter.h>
#include <wx/stackwalk.h>
#include <wx/stdpaths.h>
#include <wx/statbmp.h>
#include <wx/statbox.h>
#include <wx/sizer.h>
#include <wx/statline.h>
#include <wx/stattext.h>
#include <wx/statusbr.h>
#include <wx/sizer.h>
#include <wx/timer.h>
#include <wx/stream.h>
#include <wx/string.h>
#include <wx/clntdata.h>
#include <wx/sstream.h>
#include <wx/sstream.h>
#include <wx/tokenzr.h>
#include <wx/event.h>
#include <wx/sysopt.h>
#include <wx/settings.h>
#include <wx/sckipc.h>
#include <wx/sckipc.h>
#include <wx/sckipc.h>
#include <wx/taskbar.h>
#include <wx/file.h>
#include <wx/textctrl.h>
#include <wx/dataobj.h>
#include <wx/textdlg.h>
#include <wx/textfile.h>
#include <wx/txtstrm.h>
#include <wx/txtstrm.h>
#include <wx/valtext.h>
#include <wx/timer.h>
#include <wx/timer.h>
#include <wx/tipwin.h>
#include <wx/tglbtn.h>
#include <wx/toolbar.h>
#include <wx/tooltip.h>
#include <wx/toplevel.h>
#include <wx/treectrl.h>
#include <wx/treectrl.h>
#include <wx/uri.h>
#include <wx/event.h>
#include <wx/validate.h>
#include <wx/variant.h>
#include <wx/window.h>
#include <wx/dcclient.h>
#include <wx/utils.h>
#include <wx/wizard.h>
#include <wx/wizard.h>
#include <wx/wizard.h>
#include <wx/xrc/xmlres.h>
#include <wx/zipstrm.h>
#include <wx/zipstrm.h>
#include <wx/zipstrm.h>
#include <wx/zipstrm.h>
#include <wx/zipstrm.h>
#include <wx/zstream.h>
#include <wx/zstream.h>

typedef wxIcon wxIconOrCursor;

void main () {
// Looking at class wxAcceleratorEntry
wxAcceleratorEntry * mywxAcceleratorEntry;
// Looking at method wxAcceleratorEntry::wxAcceleratorEntry
wxAcceleratorEntry * newwxAcceleratorEntry0 = new wxAcceleratorEntry();
int  * wxAcceleratorEntrywxAcceleratorEntryflags0;
int  * wxAcceleratorEntrywxAcceleratorEntrykeyCode1;
int  * wxAcceleratorEntrywxAcceleratorEntrycmd2;
wxAcceleratorEntry * newwxAcceleratorEntry1 = new wxAcceleratorEntry( * wxAcceleratorEntrywxAcceleratorEntryflags0,  * wxAcceleratorEntrywxAcceleratorEntrykeyCode1,  * wxAcceleratorEntrywxAcceleratorEntrycmd2);
// Looking at method wxAcceleratorEntry::GetCommand
int retwxAcceleratorEntryGetCommand0 = mywxAcceleratorEntry->GetCommand();
// Looking at method wxAcceleratorEntry::GetFlags
int retwxAcceleratorEntryGetFlags0 = mywxAcceleratorEntry->GetFlags();
// Looking at method wxAcceleratorEntry::GetKeyCode
int retwxAcceleratorEntryGetKeyCode0 = mywxAcceleratorEntry->GetKeyCode();
// Looking at method wxAcceleratorEntry::Set
int  * wxAcceleratorEntrySetflags0;
int  * wxAcceleratorEntrySetkeyCode1;
int  * wxAcceleratorEntrySetcmd2;
mywxAcceleratorEntry->Set( * wxAcceleratorEntrySetflags0,  * wxAcceleratorEntrySetkeyCode1,  * wxAcceleratorEntrySetcmd2);

// Looking at class wxAcceleratorTable
wxAcceleratorTable * mywxAcceleratorTable;
// Looking at method wxAcceleratorTable::wxAcceleratorTable
wxAcceleratorTable * newwxAcceleratorTable0 = new wxAcceleratorTable();
wxAcceleratorTable  * wxAcceleratorTablewxAcceleratorTablebitmap0;
wxAcceleratorTable * newwxAcceleratorTable1 = new wxAcceleratorTable( * wxAcceleratorTablewxAcceleratorTablebitmap0);
int  * wxAcceleratorTablewxAcceleratorTablen1;
wxAcceleratorEntry  * * wxAcceleratorTablewxAcceleratorTableentriesptr2;
wxAcceleratorTable * newwxAcceleratorTable2 = new wxAcceleratorTable( * wxAcceleratorTablewxAcceleratorTablen1,  * wxAcceleratorTablewxAcceleratorTableentriesptr2);
// Looking at method wxAcceleratorTable::Ok
bool retwxAcceleratorTableOk0 = mywxAcceleratorTable->Ok();
#if wxACCESSIBILITY == 1

// Looking at class wxAccessible
wxAccessible * mywxAccessible;
// Looking at method wxAccessible::wxAccessible
wxWindow*  * wxAccessiblewxAccessiblewin0;
wxAccessible * newwxAccessible0 = new wxAccessible( * wxAccessiblewxAccessiblewin0);
// Looking at method wxAccessible::DoDefaultAction
// Looking at method wxAccessible::GetChild
// Looking at method wxAccessible::GetChildCount
// Looking at method wxAccessible::GetDefaultAction
// Looking at method wxAccessible::GetDescription
// Looking at method wxAccessible::GetFocus
// Looking at method wxAccessible::GetHelpText
// Looking at method wxAccessible::GetKeyboardShortcut
// Looking at method wxAccessible::GetLocation
// Looking at method wxAccessible::GetName
// Looking at method wxAccessible::GetParent
// Looking at method wxAccessible::GetRole
// Looking at method wxAccessible::GetSelections
// Looking at method wxAccessible::GetState
// Looking at method wxAccessible::GetValue
// Looking at method wxAccessible::GetWindow
wxWindow* retwxAccessibleGetWindow0 = mywxAccessible->GetWindow();
// Looking at method wxAccessible::HitTest
// Looking at method wxAccessible::Navigate
// Looking at method wxAccessible::NotifyEvent
// Looking at method wxAccessible::Select
// Looking at method wxAccessible::SetWindow
wxWindow*  * wxAccessibleSetWindowwindow0;
mywxAccessible->SetWindow( * wxAccessibleSetWindowwindow0);
#endif //wxACCESSIBILITY

// Looking at class wxActivateEvent
wxActivateEvent * mywxActivateEvent;
// Looking at method wxActivateEvent::wxActivateEvent
WXTYPE  * wxActivateEventwxActivateEventeventType0;
bool  * wxActivateEventwxActivateEventactive1;
int  * wxActivateEventwxActivateEventid2;
wxActivateEvent * newwxActivateEvent0 = new wxActivateEvent( * wxActivateEventwxActivateEventeventType0,  * wxActivateEventwxActivateEventactive1,  * wxActivateEventwxActivateEventid2);
// Looking at method wxActivateEvent::GetActive
bool retwxActivateEventGetActive0 = mywxActivateEvent->GetActive();

// Looking at class wxApp
wxApp * mywxApp;
// Looking at method wxApp::wxApp
wxApp * newwxApp0 = new wxApp();
// Looking at method wxApp::argc
// Looking at method wxApp::argv
// Looking at method wxApp::CreateLogTarget
// Looking at method wxApp::Dispatch
// Looking at method wxApp::ExitMainLoop
// Looking at method wxApp::FilterEvent
wxEvent  * wxAppFilterEventevent0;
int retwxAppFilterEvent0 = mywxApp->FilterEvent( * wxAppFilterEventevent0);
// Looking at method wxApp::GetAppName
wxString retwxAppGetAppName0 = mywxApp->GetAppName();
// Looking at method wxApp::GetClassName
wxString retwxAppGetClassName0 = mywxApp->GetClassName();
// Looking at method wxApp::GetExitOnFrameDelete
bool retwxAppGetExitOnFrameDelete0 = mywxApp->GetExitOnFrameDelete();
// Looking at method wxApp::GetInstance
static wxAppConsole * retwxAppGetInstance0 = mywxApp->GetInstance();
// Looking at method wxApp::GetTopWindow
// Looking at method wxApp::GetUseBestVisual
bool retwxAppGetUseBestVisual0 = mywxApp->GetUseBestVisual();
// Looking at method wxApp::GetVendorName
wxString retwxAppGetVendorName0 = mywxApp->GetVendorName();
// Looking at method wxApp::IsActive
bool retwxAppIsActive0 = mywxApp->IsActive();
// Looking at method wxApp::IsMainLoopRunning
static bool retwxAppIsMainLoopRunning0 = mywxApp->IsMainLoopRunning();
// Looking at method wxApp::MainLoop
// Looking at method wxApp::OnAssert
#if __WXDEBUG__ == 1
wxChar * * wxAppOnAssertfile0;
int  * wxAppOnAssertline1;
wxChar * * wxAppOnAssertcond2;
wxChar * * wxAppOnAssertmsg3;
mywxApp->OnAssert( * wxAppOnAssertfile0,  * wxAppOnAssertline1,  * wxAppOnAssertcond2,  * wxAppOnAssertmsg3);
#endif //__WXDEBUG__
// Looking at method wxApp::OnCmdLineError
wxCmdLineParser  * wxAppOnCmdLineErrorparser0;
bool retwxAppOnCmdLineError0 = mywxApp->OnCmdLineError( * wxAppOnCmdLineErrorparser0);
// Looking at method wxApp::OnCmdLineHelp
wxCmdLineParser  * wxAppOnCmdLineHelpparser0;
bool retwxAppOnCmdLineHelp0 = mywxApp->OnCmdLineHelp( * wxAppOnCmdLineHelpparser0);
// Looking at method wxApp::OnCmdLineParsed
wxCmdLineParser  * wxAppOnCmdLineParsedparser0;
bool retwxAppOnCmdLineParsed0 = mywxApp->OnCmdLineParsed( * wxAppOnCmdLineParsedparser0);
// Looking at method wxApp::OnExceptionInMainLoop
// Looking at method wxApp::OnExit
// Looking at method wxApp::OnFatalException
mywxApp->OnFatalException();
// Looking at method wxApp::OnInit
bool retwxAppOnInit0 = mywxApp->OnInit();
// Looking at method wxApp::OnInitCmdLine
wxCmdLineParser  * wxAppOnInitCmdLineparser0;
mywxApp->OnInitCmdLine( * wxAppOnInitCmdLineparser0);
// Looking at method wxApp::OnRun
// Looking at method wxApp::OnUnhandledException
// Looking at method wxApp::ProcessMessage
// Looking at method wxApp::Pending
// Looking at method wxApp::SendIdleEvents
wxWindow*  * wxAppSendIdleEventswin0;
wxIdleEvent  * wxAppSendIdleEventsevent1;
bool retwxAppSendIdleEvents0 = mywxApp->SendIdleEvents( * wxAppSendIdleEventswin0,  * wxAppSendIdleEventsevent1);
// Looking at method wxApp::SetAppName
wxString  * wxAppSetAppNamename0;
mywxApp->SetAppName( * wxAppSetAppNamename0);
// Looking at method wxApp::SetClassName
wxString  * wxAppSetClassNamename0;
mywxApp->SetClassName( * wxAppSetClassNamename0);
// Looking at method wxApp::SetExitOnFrameDelete
bool  * wxAppSetExitOnFrameDeleteflag0;
mywxApp->SetExitOnFrameDelete( * wxAppSetExitOnFrameDeleteflag0);
// Looking at method wxApp::SetInstance
wxAppConsole*  * wxAppSetInstanceapp0;
mywxApp->SetInstance( * wxAppSetInstanceapp0);
// Looking at method wxApp::SetTopWindow
wxWindow*  * wxAppSetTopWindowwindow0;
mywxApp->SetTopWindow( * wxAppSetTopWindowwindow0);
// Looking at method wxApp::SetVendorName
wxString  * wxAppSetVendorNamename0;
mywxApp->SetVendorName( * wxAppSetVendorNamename0);
// Looking at method wxApp::SetUseBestVisual
bool  * wxAppSetUseBestVisualflag0;
mywxApp->SetUseBestVisual( * wxAppSetUseBestVisualflag0);
// Looking at method wxApp::HandleEvent
// Looking at method wxApp::Yield
bool  * wxAppYieldonlyIfNeeded0;
bool retwxAppYield0 = mywxApp->Yield( * wxAppYieldonlyIfNeeded0);

// Looking at class wxArchiveInputStream
wxArchiveInputStream * mywxArchiveInputStream;
// Looking at method wxArchiveInputStream::CloseEntry
bool retwxArchiveInputStreamCloseEntry0 = mywxArchiveInputStream->CloseEntry();
// Looking at method wxArchiveInputStream::GetNextEntry
wxArchiveEntry* retwxArchiveInputStreamGetNextEntry0 = mywxArchiveInputStream->GetNextEntry();
// Looking at method wxArchiveInputStream::OpenEntry
wxArchiveEntry  * wxArchiveInputStreamOpenEntryentry0;
bool retwxArchiveInputStreamOpenEntry0 = mywxArchiveInputStream->OpenEntry( * wxArchiveInputStreamOpenEntryentry0);
#if wxUSE_STL == 1

// Looking at class wxArchiveIterator
wxArchiveIterator * mywxArchiveIterator;
// Looking at method wxArchiveIterator::wxArchiveIterator
wxArchiveIterator * newwxArchiveIterator0 = new wxArchiveIterator();
Arc  * wxArchiveIteratorwxArchiveIteratorarc0;
wxArchiveIterator * newwxArchiveIterator1 = new wxArchiveIterator( * wxArchiveIteratorwxArchiveIteratorarc0);
#endif //wxUSE_STL

// Looking at class wxArchiveNotifier
wxArchiveNotifier * mywxArchiveNotifier;
// Looking at method wxArchiveNotifier::OnEntryUpdated
class wxArchiveEntry  * wxArchiveNotifierOnEntryUpdatedentry0;
mywxArchiveNotifier->OnEntryUpdated( * wxArchiveNotifierOnEntryUpdatedentry0);

// Looking at class wxArchiveOutputStream
wxArchiveOutputStream * mywxArchiveOutputStream;
// Looking at method wxArchiveOutputStream::Close
bool retwxArchiveOutputStreamClose0 = mywxArchiveOutputStream->Close();
// Looking at method wxArchiveOutputStream::CloseEntry
bool retwxArchiveOutputStreamCloseEntry0 = mywxArchiveOutputStream->CloseEntry();
// Looking at method wxArchiveOutputStream::CopyArchiveMetaData
wxArchiveInputStream  * wxArchiveOutputStreamCopyArchiveMetaDatastream0;
bool retwxArchiveOutputStreamCopyArchiveMetaData0 = mywxArchiveOutputStream->CopyArchiveMetaData( * wxArchiveOutputStreamCopyArchiveMetaDatastream0);
// Looking at method wxArchiveOutputStream::CopyEntry
wxArchiveEntry*  * wxArchiveOutputStreamCopyEntryentry0;
wxArchiveInputStream  * wxArchiveOutputStreamCopyEntrystream1;
bool retwxArchiveOutputStreamCopyEntry0 = mywxArchiveOutputStream->CopyEntry( * wxArchiveOutputStreamCopyEntryentry0,  * wxArchiveOutputStreamCopyEntrystream1);
// Looking at method wxArchiveOutputStream::PutNextDirEntry
wxString  * wxArchiveOutputStreamPutNextDirEntryname0;
wxDateTime  * wxArchiveOutputStreamPutNextDirEntrydt1;
bool retwxArchiveOutputStreamPutNextDirEntry0 = mywxArchiveOutputStream->PutNextDirEntry( * wxArchiveOutputStreamPutNextDirEntryname0,  * wxArchiveOutputStreamPutNextDirEntrydt1);
// Looking at method wxArchiveOutputStream::PutNextEntry
wxArchiveEntry*  * wxArchiveOutputStreamPutNextEntryentry0;
bool retwxArchiveOutputStreamPutNextEntry0 = mywxArchiveOutputStream->PutNextEntry( * wxArchiveOutputStreamPutNextEntryentry0);
wxString  * wxArchiveOutputStreamPutNextEntryname1;
wxDateTime  * wxArchiveOutputStreamPutNextEntrydt2;
off_t  * wxArchiveOutputStreamPutNextEntrysize3;
bool retwxArchiveOutputStreamPutNextEntry1 = mywxArchiveOutputStream->PutNextEntry( * wxArchiveOutputStreamPutNextEntryname1,  * wxArchiveOutputStreamPutNextEntrydt2,  * wxArchiveOutputStreamPutNextEntrysize3);

// Looking at class wxArrayString
wxArrayString * mywxArrayString;
// Looking at method wxArrayString::wxArrayString
wxArrayString * newwxArrayString0 = new wxArrayString();
wxArrayString  * wxArrayStringwxArrayStringarray0;
wxArrayString * newwxArrayString1 = new wxArrayString( * wxArrayStringwxArrayStringarray0);
// Looking at method wxArrayString::Add
wxString  * wxArrayStringAddstr0;
size_t  * wxArrayStringAddcopies1;
size_t retwxArrayStringAdd0 = mywxArrayString->Add( * wxArrayStringAddstr0,  * wxArrayStringAddcopies1);
// Looking at method wxArrayString::Alloc
size_t  * wxArrayStringAllocnCount0;
mywxArrayString->Alloc( * wxArrayStringAllocnCount0);
// Looking at method wxArrayString::Clear
mywxArrayString->Clear();
// Looking at method wxArrayString::Count
size_t retwxArrayStringCount0 = mywxArrayString->Count();
// Looking at method wxArrayString::Empty
mywxArrayString->Empty();
// Looking at method wxArrayString::GetCount
size_t retwxArrayStringGetCount0 = mywxArrayString->GetCount();
// Looking at method wxArrayString::Index
char *  * wxArrayStringIndexsz0;
bool  * wxArrayStringIndexbCase1;
bool  * wxArrayStringIndexbFromEnd2;
int retwxArrayStringIndex0 = mywxArrayString->Index( * wxArrayStringIndexsz0,  * wxArrayStringIndexbCase1,  * wxArrayStringIndexbFromEnd2);
// Looking at method wxArrayString::Insert
wxString  * wxArrayStringInsertstr0;
size_t  * wxArrayStringInsertnIndex1;
size_t  * wxArrayStringInsertcopies2;
mywxArrayString->Insert( * wxArrayStringInsertstr0,  * wxArrayStringInsertnIndex1,  * wxArrayStringInsertcopies2);
// Looking at method wxArrayString::IsEmpty
bool retwxArrayStringIsEmpty0 = mywxArrayString->IsEmpty();
// Looking at method wxArrayString::Item
size_t  * wxArrayStringItemnIndex0;
wxString retwxArrayStringItem0 = mywxArrayString->Item( * wxArrayStringItemnIndex0);
// Looking at method wxArrayString::Last
wxString retwxArrayStringLast0 = mywxArrayString->Last();
// Looking at method wxArrayString::Remove
char *  * wxArrayStringRemovesz0;
mywxArrayString->Remove( * wxArrayStringRemovesz0);
// Looking at method wxArrayString::RemoveAt
size_t  * wxArrayStringRemoveAtnIndex0;
size_t  * wxArrayStringRemoveAtcount1;
mywxArrayString->RemoveAt( * wxArrayStringRemoveAtnIndex0,  * wxArrayStringRemoveAtcount1);
// Looking at method wxArrayString::Shrink
mywxArrayString->Shrink();
// Looking at method wxArrayString::Sort
bool  * wxArrayStringSortreverseOrder0;
mywxArrayString->Sort( * wxArrayStringSortreverseOrder0);
CompareFunction  * wxArrayStringSortcompareFunction1;
mywxArrayString->Sort( * wxArrayStringSortcompareFunction1);

// Looking at class wxBitmap
wxBitmap * mywxBitmap;
// Looking at method wxBitmap::wxBitmap
wxBitmap * newwxBitmap0 = new wxBitmap();
wxBitmap  * wxBitmapwxBitmapbitmap0;
wxBitmap * newwxBitmap1 = new wxBitmap( * wxBitmapwxBitmapbitmap0);
void*  * wxBitmapwxBitmapdata1;
int  * wxBitmapwxBitmaptype2;
int  * wxBitmapwxBitmapwidth3;
int  * wxBitmapwxBitmapheight4;
int  * wxBitmapwxBitmapdepth5;
wxBitmap * newwxBitmap2 = new wxBitmap( * wxBitmapwxBitmapdata1,  * wxBitmapwxBitmaptype2,  * wxBitmapwxBitmapwidth3,  * wxBitmapwxBitmapheight4,  * wxBitmapwxBitmapdepth5);
char  * * wxBitmapwxBitmapbitsptr6;
int  * wxBitmapwxBitmapwidth7;
int  * wxBitmapwxBitmapheight8;
int  * wxBitmapwxBitmapdepth9;
wxBitmap * newwxBitmap3 = new wxBitmap( * wxBitmapwxBitmapbitsptr6,  * wxBitmapwxBitmapwidth7,  * wxBitmapwxBitmapheight8,  * wxBitmapwxBitmapdepth9);
int  * wxBitmapwxBitmapwidth10;
int  * wxBitmapwxBitmapheight11;
int  * wxBitmapwxBitmapdepth12;
wxBitmap * newwxBitmap4 = new wxBitmap( * wxBitmapwxBitmapwidth10,  * wxBitmapwxBitmapheight11,  * wxBitmapwxBitmapdepth12);
char**  * wxBitmapwxBitmapbits13;
wxBitmap * newwxBitmap5 = new wxBitmap( * wxBitmapwxBitmapbits13);
wxString  * wxBitmapwxBitmapname14;
long  * wxBitmapwxBitmaptype15;
wxBitmap * newwxBitmap6 = new wxBitmap( * wxBitmapwxBitmapname14,  * wxBitmapwxBitmaptype15);
wxImage  * wxBitmapwxBitmapimg16;
int  * wxBitmapwxBitmapdepth17;
wxBitmap * newwxBitmap7 = new wxBitmap( * wxBitmapwxBitmapimg16,  * wxBitmapwxBitmapdepth17);
// Looking at method wxBitmap::AddHandler
wxBitmapHandler*  * wxBitmapAddHandlerhandler0;
mywxBitmap->AddHandler( * wxBitmapAddHandlerhandler0);
// Looking at method wxBitmap::CleanUpHandlers
mywxBitmap->CleanUpHandlers();
// Looking at method wxBitmap::ConvertToImage
wxImage retwxBitmapConvertToImage0 = mywxBitmap->ConvertToImage();
// Looking at method wxBitmap::CopyFromIcon
wxIcon  * wxBitmapCopyFromIconicon0;
bool retwxBitmapCopyFromIcon0 = mywxBitmap->CopyFromIcon( * wxBitmapCopyFromIconicon0);
// Looking at method wxBitmap::Create
// Looking at method wxBitmap::FindHandler
wxString  * wxBitmapFindHandlername0;
static wxBitmapHandler* retwxBitmapFindHandler0 = mywxBitmap->FindHandler( * wxBitmapFindHandlername0);
wxString  * wxBitmapFindHandlerextension1;
wxBitmapType  * wxBitmapFindHandlerbitmapType2;
static wxBitmapHandler* retwxBitmapFindHandler1 = mywxBitmap->FindHandler( * wxBitmapFindHandlerextension1,  * wxBitmapFindHandlerbitmapType2);
wxBitmapType  * wxBitmapFindHandlerbitmapType3;
static wxBitmapHandler* retwxBitmapFindHandler2 = mywxBitmap->FindHandler( * wxBitmapFindHandlerbitmapType3);
// Looking at method wxBitmap::GetDepth
int retwxBitmapGetDepth0 = mywxBitmap->GetDepth();
// Looking at method wxBitmap::GetHandlers
static wxList retwxBitmapGetHandlers0 = mywxBitmap->GetHandlers();
// Looking at method wxBitmap::GetHeight
int retwxBitmapGetHeight0 = mywxBitmap->GetHeight();
// Looking at method wxBitmap::GetPalette
wxPalette* retwxBitmapGetPalette0 = mywxBitmap->GetPalette();
// Looking at method wxBitmap::GetMask
wxMask* retwxBitmapGetMask0 = mywxBitmap->GetMask();
// Looking at method wxBitmap::GetWidth
int retwxBitmapGetWidth0 = mywxBitmap->GetWidth();
// Looking at method wxBitmap::GetSubBitmap
wxRect * wxBitmapGetSubBitmaprect0;
wxBitmap retwxBitmapGetSubBitmap0 = mywxBitmap->GetSubBitmap( * wxBitmapGetSubBitmaprect0);
// Looking at method wxBitmap::InitStandardHandlers
mywxBitmap->InitStandardHandlers();
// Looking at method wxBitmap::InsertHandler
wxBitmapHandler*  * wxBitmapInsertHandlerhandler0;
mywxBitmap->InsertHandler( * wxBitmapInsertHandlerhandler0);
// Looking at method wxBitmap::LoadFile
wxString  * wxBitmapLoadFilename0;
wxBitmapType  * wxBitmapLoadFiletype1;
bool retwxBitmapLoadFile0 = mywxBitmap->LoadFile( * wxBitmapLoadFilename0,  * wxBitmapLoadFiletype1);
// Looking at method wxBitmap::Ok
bool retwxBitmapOk0 = mywxBitmap->Ok();
// Looking at method wxBitmap::RemoveHandler
wxString  * wxBitmapRemoveHandlername0;
static bool retwxBitmapRemoveHandler0 = mywxBitmap->RemoveHandler( * wxBitmapRemoveHandlername0);
// Looking at method wxBitmap::SaveFile
wxString  * wxBitmapSaveFilename0;
wxBitmapType  * wxBitmapSaveFiletype1;
wxPalette*  * wxBitmapSaveFilepalette2;
bool retwxBitmapSaveFile0 = mywxBitmap->SaveFile( * wxBitmapSaveFilename0,  * wxBitmapSaveFiletype1,  * wxBitmapSaveFilepalette2);
// Looking at method wxBitmap::SetDepth
int  * wxBitmapSetDepthdepth0;
mywxBitmap->SetDepth( * wxBitmapSetDepthdepth0);
// Looking at method wxBitmap::SetHeight
int  * wxBitmapSetHeightheight0;
mywxBitmap->SetHeight( * wxBitmapSetHeightheight0);
// Looking at method wxBitmap::SetMask
wxMask*  * wxBitmapSetMaskmask0;
mywxBitmap->SetMask( * wxBitmapSetMaskmask0);
// Looking at method wxBitmap::SetPalette
wxPalette  * wxBitmapSetPalettepalette0;
mywxBitmap->SetPalette( * wxBitmapSetPalettepalette0);
// Looking at method wxBitmap::SetWidth
int  * wxBitmapSetWidthwidth0;
mywxBitmap->SetWidth( * wxBitmapSetWidthwidth0);

// Looking at class wxBitmapButton
wxBitmapButton * mywxBitmapButton;
// Looking at method wxBitmapButton::wxBitmapButton
wxBitmapButton * newwxBitmapButton0 = new wxBitmapButton();
wxWindow*  * wxBitmapButtonwxBitmapButtonparent0;
wxWindowID  * wxBitmapButtonwxBitmapButtonid1;
wxBitmap  * wxBitmapButtonwxBitmapButtonbitmap2;
wxPoint  * wxBitmapButtonwxBitmapButtonpos3;
wxSize  * wxBitmapButtonwxBitmapButtonsize4;
long  * wxBitmapButtonwxBitmapButtonstyle5;
wxValidator  * wxBitmapButtonwxBitmapButtonvalidator6;
wxString  * wxBitmapButtonwxBitmapButtonname7;
wxBitmapButton * newwxBitmapButton1 = new wxBitmapButton( * wxBitmapButtonwxBitmapButtonparent0,  * wxBitmapButtonwxBitmapButtonid1,  * wxBitmapButtonwxBitmapButtonbitmap2,  * wxBitmapButtonwxBitmapButtonpos3,  * wxBitmapButtonwxBitmapButtonsize4,  * wxBitmapButtonwxBitmapButtonstyle5,  * wxBitmapButtonwxBitmapButtonvalidator6,  * wxBitmapButtonwxBitmapButtonname7);
// Looking at method wxBitmapButton::Create
wxWindow*  * wxBitmapButtonCreateparent0;
wxWindowID  * wxBitmapButtonCreateid1;
wxBitmap  * wxBitmapButtonCreatebitmap2;
wxPoint  * wxBitmapButtonCreatepos3;
wxSize  * wxBitmapButtonCreatesize4;
long  * wxBitmapButtonCreatestyle5;
wxValidator  * wxBitmapButtonCreatevalidator6;
wxString  * wxBitmapButtonCreatename7;
bool retwxBitmapButtonCreate0 = mywxBitmapButton->Create( * wxBitmapButtonCreateparent0,  * wxBitmapButtonCreateid1,  * wxBitmapButtonCreatebitmap2,  * wxBitmapButtonCreatepos3,  * wxBitmapButtonCreatesize4,  * wxBitmapButtonCreatestyle5,  * wxBitmapButtonCreatevalidator6,  * wxBitmapButtonCreatename7);
// Looking at method wxBitmapButton::GetBitmapDisabled
wxBitmap retwxBitmapButtonGetBitmapDisabled0 = mywxBitmapButton->GetBitmapDisabled();
// Looking at method wxBitmapButton::GetBitmapFocus
wxBitmap retwxBitmapButtonGetBitmapFocus0 = mywxBitmapButton->GetBitmapFocus();
// Looking at method wxBitmapButton::GetBitmapLabel
wxBitmap retwxBitmapButtonGetBitmapLabel0 = mywxBitmapButton->GetBitmapLabel();
// Looking at method wxBitmapButton::GetBitmapSelected
wxBitmap retwxBitmapButtonGetBitmapSelected0 = mywxBitmapButton->GetBitmapSelected();
// Looking at method wxBitmapButton::SetBitmapDisabled
wxBitmap  * wxBitmapButtonSetBitmapDisabledbitmap0;
mywxBitmapButton->SetBitmapDisabled( * wxBitmapButtonSetBitmapDisabledbitmap0);
// Looking at method wxBitmapButton::SetBitmapFocus
wxBitmap  * wxBitmapButtonSetBitmapFocusbitmap0;
mywxBitmapButton->SetBitmapFocus( * wxBitmapButtonSetBitmapFocusbitmap0);
// Looking at method wxBitmapButton::SetBitmapLabel
wxBitmap  * wxBitmapButtonSetBitmapLabelbitmap0;
mywxBitmapButton->SetBitmapLabel( * wxBitmapButtonSetBitmapLabelbitmap0);
// Looking at method wxBitmapButton::SetBitmapSelected
wxBitmap  * wxBitmapButtonSetBitmapSelectedbitmap0;
mywxBitmapButton->SetBitmapSelected( * wxBitmapButtonSetBitmapSelectedbitmap0);

// Looking at class wxBitmapDataObject
wxBitmapDataObject * mywxBitmapDataObject;
// Looking at method wxBitmapDataObject::GetBitmap
// Looking at method wxBitmapDataObject::SetBitmap

// Looking at class wxBoxSizer
wxBoxSizer * mywxBoxSizer;
// Looking at method wxBoxSizer::wxBoxSizer
int  * wxBoxSizerwxBoxSizerorient0;
wxBoxSizer * newwxBoxSizer0 = new wxBoxSizer( * wxBoxSizerwxBoxSizerorient0);
// Looking at method wxBoxSizer::RecalcSizes
mywxBoxSizer->RecalcSizes();
// Looking at method wxBoxSizer::CalcMin
wxSize retwxBoxSizerCalcMin0 = mywxBoxSizer->CalcMin();
// Looking at method wxBoxSizer::GetOrientation
int retwxBoxSizerGetOrientation0 = mywxBoxSizer->GetOrientation();

// Looking at class wxBrush
wxBrush * mywxBrush;
// Looking at method wxBrush::wxBrush
wxBrush * newwxBrush0 = new wxBrush();
wxColour  * wxBrushwxBrushcolour0;
int  * wxBrushwxBrushstyle1;
wxBrush * newwxBrush1 = new wxBrush( * wxBrushwxBrushcolour0,  * wxBrushwxBrushstyle1);
wxString  * wxBrushwxBrushcolourName2;
int  * wxBrushwxBrushstyle3;
wxBrush * newwxBrush2 = new wxBrush( * wxBrushwxBrushcolourName2,  * wxBrushwxBrushstyle3);
wxBitmap  * wxBrushwxBrushstippleBitmap4;
wxBrush * newwxBrush3 = new wxBrush( * wxBrushwxBrushstippleBitmap4);
wxBrush  * wxBrushwxBrushbrush5;
wxBrush * newwxBrush4 = new wxBrush( * wxBrushwxBrushbrush5);
// Looking at method wxBrush::GetColour
wxColour retwxBrushGetColour0 = mywxBrush->GetColour();
// Looking at method wxBrush::GetStipple
wxBitmap * retwxBrushGetStipple0 = mywxBrush->GetStipple();
// Looking at method wxBrush::GetStyle
int retwxBrushGetStyle0 = mywxBrush->GetStyle();
// Looking at method wxBrush::IsHatch
bool retwxBrushIsHatch0 = mywxBrush->IsHatch();
// Looking at method wxBrush::Ok
bool retwxBrushOk0 = mywxBrush->Ok();
// Looking at method wxBrush::SetColour
wxColour  * wxBrushSetColourcolour0;
mywxBrush->SetColour( * wxBrushSetColourcolour0);
wxString  * wxBrushSetColourcolourName1;
mywxBrush->SetColour( * wxBrushSetColourcolourName1);
unsigned char  * wxBrushSetColourred2;
unsigned char  * wxBrushSetColourgreen3;
unsigned char  * wxBrushSetColourblue4;
mywxBrush->SetColour( * wxBrushSetColourred2,  * wxBrushSetColourgreen3,  * wxBrushSetColourblue4);
// Looking at method wxBrush::SetStipple
wxBitmap  * wxBrushSetStipplebitmap0;
mywxBrush->SetStipple( * wxBrushSetStipplebitmap0);
// Looking at method wxBrush::SetStyle
int  * wxBrushSetStylestyle0;
mywxBrush->SetStyle( * wxBrushSetStylestyle0);

// Looking at class wxBrushList
wxBrushList * mywxBrushList;
// Looking at method wxBrushList::wxBrushList
mywxBrushList->wxBrushList();
// Looking at method wxBrushList::AddBrush
wxBrush * * wxBrushListAddBrushbrush0;
mywxBrushList->AddBrush( * wxBrushListAddBrushbrush0);
// Looking at method wxBrushList::FindOrCreateBrush
wxColour  * wxBrushListFindOrCreateBrushcolour0;
int  * wxBrushListFindOrCreateBrushstyle1;
wxBrush * retwxBrushListFindOrCreateBrush0 = mywxBrushList->FindOrCreateBrush( * wxBrushListFindOrCreateBrushcolour0,  * wxBrushListFindOrCreateBrushstyle1);
wxString  * wxBrushListFindOrCreateBrushcolourName2;
int  * wxBrushListFindOrCreateBrushstyle3;
wxBrush * retwxBrushListFindOrCreateBrush1 = mywxBrushList->FindOrCreateBrush( * wxBrushListFindOrCreateBrushcolourName2,  * wxBrushListFindOrCreateBrushstyle3);
// Looking at method wxBrushList::RemoveBrush
wxBrush * * wxBrushListRemoveBrushbrush0;
mywxBrushList->RemoveBrush( * wxBrushListRemoveBrushbrush0);

// Looking at class wxBufferedDC
wxBufferedDC * mywxBufferedDC;
// Looking at method wxBufferedDC::wxBufferedDC
wxBufferedDC * newwxBufferedDC0 = new wxBufferedDC();
wxDC * * wxBufferedDCwxBufferedDCdc0;
wxSize  * wxBufferedDCwxBufferedDCarea1;
wxBufferedDC * newwxBufferedDC1 = new wxBufferedDC( * wxBufferedDCwxBufferedDCdc0,  * wxBufferedDCwxBufferedDCarea1);
wxDC * * wxBufferedDCwxBufferedDCdc2;
wxBitmap  * wxBufferedDCwxBufferedDCbuffer3;
wxBufferedDC * newwxBufferedDC2 = new wxBufferedDC( * wxBufferedDCwxBufferedDCdc2,  * wxBufferedDCwxBufferedDCbuffer3);
// Looking at method wxBufferedDC::Init
wxDC * * wxBufferedDCInitdc0;
wxSize  * wxBufferedDCInitarea1;
mywxBufferedDC->Init( * wxBufferedDCInitdc0,  * wxBufferedDCInitarea1);
wxDC * * wxBufferedDCInitdc2;
wxBitmap  * wxBufferedDCInitbuffer3;
mywxBufferedDC->Init( * wxBufferedDCInitdc2,  * wxBufferedDCInitbuffer3);

// Looking at class wxBufferedInputStream
wxBufferedInputStream * mywxBufferedInputStream;

// Looking at class wxBufferedOutputStream
wxBufferedOutputStream * mywxBufferedOutputStream;
// Looking at method wxBufferedOutputStream::wxBufferedOutputStream
wxOutputStream  * wxBufferedOutputStreamwxBufferedOutputStreamparent0;
wxBufferedOutputStream * newwxBufferedOutputStream0 = new wxBufferedOutputStream( * wxBufferedOutputStreamwxBufferedOutputStreamparent0);
// Looking at method wxBufferedOutputStream::SeekO
off_t  * wxBufferedOutputStreamSeekOpos0;
wxSeekMode  * wxBufferedOutputStreamSeekOmode1;
off_t retwxBufferedOutputStreamSeekO0 = mywxBufferedOutputStream->SeekO( * wxBufferedOutputStreamSeekOpos0,  * wxBufferedOutputStreamSeekOmode1);
// Looking at method wxBufferedOutputStream::Sync
mywxBufferedOutputStream->Sync();

// Looking at class wxBufferedPaintDC
wxBufferedPaintDC * mywxBufferedPaintDC;
// Looking at method wxBufferedPaintDC::wxBufferedPaintDC
wxWindow * * wxBufferedPaintDCwxBufferedPaintDCwindow0;
wxBitmap  * wxBufferedPaintDCwxBufferedPaintDCbuffer1;
wxBufferedPaintDC * newwxBufferedPaintDC0 = new wxBufferedPaintDC( * wxBufferedPaintDCwxBufferedPaintDCwindow0,  * wxBufferedPaintDCwxBufferedPaintDCbuffer1);

// Looking at class wxBusyCursor
wxBusyCursor * mywxBusyCursor;
// Looking at method wxBusyCursor::wxBusyCursor
wxCursor*  * wxBusyCursorwxBusyCursorcursor0;
wxBusyCursor * newwxBusyCursor0 = new wxBusyCursor( * wxBusyCursorwxBusyCursorcursor0);

// Looking at class wxBusyInfo
wxBusyInfo * mywxBusyInfo;
// Looking at method wxBusyInfo::wxBusyInfo
wxString  * wxBusyInfowxBusyInfomsg0;
wxWindow*  * wxBusyInfowxBusyInfoparent1;
wxBusyInfo * newwxBusyInfo0 = new wxBusyInfo( * wxBusyInfowxBusyInfomsg0,  * wxBusyInfowxBusyInfoparent1);

// Looking at class wxButton
wxButton * mywxButton;
// Looking at method wxButton::wxButton
wxButton * newwxButton0 = new wxButton();
wxWindow*  * wxButtonwxButtonparent0;
wxWindowID  * wxButtonwxButtonid1;
wxString  * wxButtonwxButtonlabel2;
wxPoint  * wxButtonwxButtonpos3;
wxSize  * wxButtonwxButtonsize4;
long  * wxButtonwxButtonstyle5;
wxValidator  * wxButtonwxButtonvalidator6;
wxString  * wxButtonwxButtonname7;
wxButton * newwxButton1 = new wxButton( * wxButtonwxButtonparent0,  * wxButtonwxButtonid1,  * wxButtonwxButtonlabel2,  * wxButtonwxButtonpos3,  * wxButtonwxButtonsize4,  * wxButtonwxButtonstyle5,  * wxButtonwxButtonvalidator6,  * wxButtonwxButtonname7);
// Looking at method wxButton::Create
wxWindow*  * wxButtonCreateparent0;
wxWindowID  * wxButtonCreateid1;
wxString  * wxButtonCreatelabel2;
wxPoint  * wxButtonCreatepos3;
wxSize  * wxButtonCreatesize4;
long  * wxButtonCreatestyle5;
wxValidator  * wxButtonCreatevalidator6;
wxString  * wxButtonCreatename7;
bool retwxButtonCreate0 = mywxButton->Create( * wxButtonCreateparent0,  * wxButtonCreateid1,  * wxButtonCreatelabel2,  * wxButtonCreatepos3,  * wxButtonCreatesize4,  * wxButtonCreatestyle5,  * wxButtonCreatevalidator6,  * wxButtonCreatename7);
// Looking at method wxButton::GetLabel
wxString retwxButtonGetLabel0 = mywxButton->GetLabel();
// Looking at method wxButton::GetDefaultSize
wxSize retwxButtonGetDefaultSize0 = mywxButton->GetDefaultSize();
// Looking at method wxButton::SetDefault
mywxButton->SetDefault();
// Looking at method wxButton::SetLabel
wxString  * wxButtonSetLabellabel0;
mywxButton->SetLabel( * wxButtonSetLabellabel0);

// Looking at class wxCSConv
wxCSConv * mywxCSConv;
// Looking at method wxCSConv::wxCSConv
wxChar*  * wxCSConvwxCSConvcharset0;
wxCSConv * newwxCSConv0 = new wxCSConv( * wxCSConvwxCSConvcharset0);
wxFontEncoding  * wxCSConvwxCSConvencoding1;
wxCSConv * newwxCSConv1 = new wxCSConv( * wxCSConvwxCSConvencoding1);
// Looking at method wxCSConv::MB2WC
wchar_t*  * wxCSConvMB2WCbuf0;
char*  * wxCSConvMB2WCpsz1;
size_t  * wxCSConvMB2WCn2;
size_t retwxCSConvMB2WC0 = mywxCSConv->MB2WC( * wxCSConvMB2WCbuf0,  * wxCSConvMB2WCpsz1,  * wxCSConvMB2WCn2);
// Looking at method wxCSConv::WC2MB
char*  * wxCSConvWC2MBbuf0;
wchar_t*  * wxCSConvWC2MBpsz1;
size_t  * wxCSConvWC2MBn2;
size_t retwxCSConvWC2MB0 = mywxCSConv->WC2MB( * wxCSConvWC2MBbuf0,  * wxCSConvWC2MBpsz1,  * wxCSConvWC2MBn2);

// Looking at class wxCalculateLayoutEvent
wxCalculateLayoutEvent * mywxCalculateLayoutEvent;
// Looking at method wxCalculateLayoutEvent::wxCalculateLayoutEvent
wxWindowID  * wxCalculateLayoutEventwxCalculateLayoutEventid0;
wxCalculateLayoutEvent * newwxCalculateLayoutEvent0 = new wxCalculateLayoutEvent( * wxCalculateLayoutEventwxCalculateLayoutEventid0);
// Looking at method wxCalculateLayoutEvent::GetFlags
int retwxCalculateLayoutEventGetFlags0 = mywxCalculateLayoutEvent->GetFlags();
// Looking at method wxCalculateLayoutEvent::GetRect
wxRect retwxCalculateLayoutEventGetRect0 = mywxCalculateLayoutEvent->GetRect();
// Looking at method wxCalculateLayoutEvent::SetFlags
int  * wxCalculateLayoutEventSetFlagsflags0;
mywxCalculateLayoutEvent->SetFlags( * wxCalculateLayoutEventSetFlagsflags0);
// Looking at method wxCalculateLayoutEvent::SetRect
wxRect  * wxCalculateLayoutEventSetRectrect0;
mywxCalculateLayoutEvent->SetRect( * wxCalculateLayoutEventSetRectrect0);

// Looking at class wxCalendarCtrl
wxCalendarCtrl * mywxCalendarCtrl;
// Looking at method wxCalendarCtrl::wxCalendarCtrl
wxCalendarCtrl * newwxCalendarCtrl0 = new wxCalendarCtrl();
wxWindow*  * wxCalendarCtrlwxCalendarCtrlparent0;
wxWindowID  * wxCalendarCtrlwxCalendarCtrlid1;
wxDateTime  * wxCalendarCtrlwxCalendarCtrldate2;
wxPoint  * wxCalendarCtrlwxCalendarCtrlpos3;
wxSize  * wxCalendarCtrlwxCalendarCtrlsize4;
long  * wxCalendarCtrlwxCalendarCtrlstyle5;
wxString  * wxCalendarCtrlwxCalendarCtrlname6;
wxCalendarCtrl * newwxCalendarCtrl1 = new wxCalendarCtrl( * wxCalendarCtrlwxCalendarCtrlparent0,  * wxCalendarCtrlwxCalendarCtrlid1,  * wxCalendarCtrlwxCalendarCtrldate2,  * wxCalendarCtrlwxCalendarCtrlpos3,  * wxCalendarCtrlwxCalendarCtrlsize4,  * wxCalendarCtrlwxCalendarCtrlstyle5,  * wxCalendarCtrlwxCalendarCtrlname6);
// Looking at method wxCalendarCtrl::Create
wxWindow*  * wxCalendarCtrlCreateparent0;
wxWindowID  * wxCalendarCtrlCreateid1;
wxDateTime  * wxCalendarCtrlCreatedate2;
wxPoint  * wxCalendarCtrlCreatepos3;
wxSize  * wxCalendarCtrlCreatesize4;
long  * wxCalendarCtrlCreatestyle5;
wxString  * wxCalendarCtrlCreatename6;
bool retwxCalendarCtrlCreate0 = mywxCalendarCtrl->Create( * wxCalendarCtrlCreateparent0,  * wxCalendarCtrlCreateid1,  * wxCalendarCtrlCreatedate2,  * wxCalendarCtrlCreatepos3,  * wxCalendarCtrlCreatesize4,  * wxCalendarCtrlCreatestyle5,  * wxCalendarCtrlCreatename6);
// Looking at method wxCalendarCtrl::SetDate
wxDateTime  * wxCalendarCtrlSetDatedate0;
mywxCalendarCtrl->SetDate( * wxCalendarCtrlSetDatedate0);
// Looking at method wxCalendarCtrl::GetDate
const wxDateTime retwxCalendarCtrlGetDate0 = mywxCalendarCtrl->GetDate();
// Looking at method wxCalendarCtrl::EnableYearChange
bool  * wxCalendarCtrlEnableYearChangeenable0;
mywxCalendarCtrl->EnableYearChange( * wxCalendarCtrlEnableYearChangeenable0);
// Looking at method wxCalendarCtrl::EnableMonthChange
bool  * wxCalendarCtrlEnableMonthChangeenable0;
mywxCalendarCtrl->EnableMonthChange( * wxCalendarCtrlEnableMonthChangeenable0);
// Looking at method wxCalendarCtrl::EnableHolidayDisplay
bool  * wxCalendarCtrlEnableHolidayDisplaydisplay0;
mywxCalendarCtrl->EnableHolidayDisplay( * wxCalendarCtrlEnableHolidayDisplaydisplay0);
// Looking at method wxCalendarCtrl::SetHeaderColours
wxColour  * wxCalendarCtrlSetHeaderColourscolFg0;
wxColour  * wxCalendarCtrlSetHeaderColourscolBg1;
mywxCalendarCtrl->SetHeaderColours( * wxCalendarCtrlSetHeaderColourscolFg0,  * wxCalendarCtrlSetHeaderColourscolBg1);
// Looking at method wxCalendarCtrl::GetHeaderColourFg
const wxColour retwxCalendarCtrlGetHeaderColourFg0 = mywxCalendarCtrl->GetHeaderColourFg();
// Looking at method wxCalendarCtrl::GetHeaderColourBg
const wxColour retwxCalendarCtrlGetHeaderColourBg0 = mywxCalendarCtrl->GetHeaderColourBg();
// Looking at method wxCalendarCtrl::SetHighlightColours
wxColour  * wxCalendarCtrlSetHighlightColourscolFg0;
wxColour  * wxCalendarCtrlSetHighlightColourscolBg1;
mywxCalendarCtrl->SetHighlightColours( * wxCalendarCtrlSetHighlightColourscolFg0,  * wxCalendarCtrlSetHighlightColourscolBg1);
// Looking at method wxCalendarCtrl::GetHighlightColourFg
const wxColour retwxCalendarCtrlGetHighlightColourFg0 = mywxCalendarCtrl->GetHighlightColourFg();
// Looking at method wxCalendarCtrl::GetHighlightColourBg
const wxColour retwxCalendarCtrlGetHighlightColourBg0 = mywxCalendarCtrl->GetHighlightColourBg();
// Looking at method wxCalendarCtrl::SetHolidayColours
wxColour  * wxCalendarCtrlSetHolidayColourscolFg0;
wxColour  * wxCalendarCtrlSetHolidayColourscolBg1;
mywxCalendarCtrl->SetHolidayColours( * wxCalendarCtrlSetHolidayColourscolFg0,  * wxCalendarCtrlSetHolidayColourscolBg1);
// Looking at method wxCalendarCtrl::GetHolidayColourFg
const wxColour retwxCalendarCtrlGetHolidayColourFg0 = mywxCalendarCtrl->GetHolidayColourFg();
// Looking at method wxCalendarCtrl::GetHolidayColourBg
const wxColour retwxCalendarCtrlGetHolidayColourBg0 = mywxCalendarCtrl->GetHolidayColourBg();
// Looking at method wxCalendarCtrl::GetAttr
size_t  * wxCalendarCtrlGetAttrday0;
wxCalendarDateAttr * retwxCalendarCtrlGetAttr0 = mywxCalendarCtrl->GetAttr( * wxCalendarCtrlGetAttrday0);
// Looking at method wxCalendarCtrl::SetAttr
size_t  * wxCalendarCtrlSetAttrday0;
wxCalendarDateAttr*  * wxCalendarCtrlSetAttrattr1;
mywxCalendarCtrl->SetAttr( * wxCalendarCtrlSetAttrday0,  * wxCalendarCtrlSetAttrattr1);
// Looking at method wxCalendarCtrl::SetHoliday
size_t  * wxCalendarCtrlSetHolidayday0;
mywxCalendarCtrl->SetHoliday( * wxCalendarCtrlSetHolidayday0);
// Looking at method wxCalendarCtrl::ResetAttr
size_t  * wxCalendarCtrlResetAttrday0;
mywxCalendarCtrl->ResetAttr( * wxCalendarCtrlResetAttrday0);
// Looking at method wxCalendarCtrl::HitTest
wxPoint  * wxCalendarCtrlHitTestpos0;
wxDateTime*  * wxCalendarCtrlHitTestdate1;
wxDateTime::WeekDay*  * wxCalendarCtrlHitTestwd2;
wxCalendarHitTestResult retwxCalendarCtrlHitTest0 = mywxCalendarCtrl->HitTest( * wxCalendarCtrlHitTestpos0,  * wxCalendarCtrlHitTestdate1,  * wxCalendarCtrlHitTestwd2);

// Looking at class wxCalendarDateAttr
wxCalendarDateAttr * mywxCalendarDateAttr;
// Looking at method wxCalendarDateAttr::wxCalendarDateAttr
wxCalendarDateAttr * newwxCalendarDateAttr0 = new wxCalendarDateAttr();
wxColour  * wxCalendarDateAttrwxCalendarDateAttrcolText0;
wxColour  * wxCalendarDateAttrwxCalendarDateAttrcolBack1;
wxColour  * wxCalendarDateAttrwxCalendarDateAttrcolBorder2;
wxFont  * wxCalendarDateAttrwxCalendarDateAttrfont3;
wxCalendarDateBorder  * wxCalendarDateAttrwxCalendarDateAttrborder4;
wxCalendarDateAttr * newwxCalendarDateAttr1 = new wxCalendarDateAttr( * wxCalendarDateAttrwxCalendarDateAttrcolText0,  * wxCalendarDateAttrwxCalendarDateAttrcolBack1,  * wxCalendarDateAttrwxCalendarDateAttrcolBorder2,  * wxCalendarDateAttrwxCalendarDateAttrfont3,  * wxCalendarDateAttrwxCalendarDateAttrborder4);
wxCalendarDateBorder  * wxCalendarDateAttrwxCalendarDateAttrborder5;
wxColour  * wxCalendarDateAttrwxCalendarDateAttrcolBorder6;
wxCalendarDateAttr * newwxCalendarDateAttr2 = new wxCalendarDateAttr( * wxCalendarDateAttrwxCalendarDateAttrborder5,  * wxCalendarDateAttrwxCalendarDateAttrcolBorder6);
// Looking at method wxCalendarDateAttr::SetTextColour
wxColour  * wxCalendarDateAttrSetTextColourcolText0;
mywxCalendarDateAttr->SetTextColour( * wxCalendarDateAttrSetTextColourcolText0);
// Looking at method wxCalendarDateAttr::SetBackgroundColour
wxColour  * wxCalendarDateAttrSetBackgroundColourcolBack0;
mywxCalendarDateAttr->SetBackgroundColour( * wxCalendarDateAttrSetBackgroundColourcolBack0);
// Looking at method wxCalendarDateAttr::SetBorderColour
wxColour  * wxCalendarDateAttrSetBorderColourcol0;
mywxCalendarDateAttr->SetBorderColour( * wxCalendarDateAttrSetBorderColourcol0);
// Looking at method wxCalendarDateAttr::SetFont
wxFont  * wxCalendarDateAttrSetFontfont0;
mywxCalendarDateAttr->SetFont( * wxCalendarDateAttrSetFontfont0);
// Looking at method wxCalendarDateAttr::SetBorder
wxCalendarDateBorder  * wxCalendarDateAttrSetBorderborder0;
mywxCalendarDateAttr->SetBorder( * wxCalendarDateAttrSetBorderborder0);
// Looking at method wxCalendarDateAttr::SetHoliday
bool  * wxCalendarDateAttrSetHolidayholiday0;
mywxCalendarDateAttr->SetHoliday( * wxCalendarDateAttrSetHolidayholiday0);
// Looking at method wxCalendarDateAttr::HasTextColour
bool retwxCalendarDateAttrHasTextColour0 = mywxCalendarDateAttr->HasTextColour();
// Looking at method wxCalendarDateAttr::HasBackgroundColour
bool retwxCalendarDateAttrHasBackgroundColour0 = mywxCalendarDateAttr->HasBackgroundColour();
// Looking at method wxCalendarDateAttr::HasBorderColour
bool retwxCalendarDateAttrHasBorderColour0 = mywxCalendarDateAttr->HasBorderColour();
// Looking at method wxCalendarDateAttr::HasFont
bool retwxCalendarDateAttrHasFont0 = mywxCalendarDateAttr->HasFont();
// Looking at method wxCalendarDateAttr::HasBorder
bool retwxCalendarDateAttrHasBorder0 = mywxCalendarDateAttr->HasBorder();
// Looking at method wxCalendarDateAttr::IsHoliday
bool retwxCalendarDateAttrIsHoliday0 = mywxCalendarDateAttr->IsHoliday();
// Looking at method wxCalendarDateAttr::GetTextColour
const wxColour retwxCalendarDateAttrGetTextColour0 = mywxCalendarDateAttr->GetTextColour();
// Looking at method wxCalendarDateAttr::GetBackgroundColour
const wxColour retwxCalendarDateAttrGetBackgroundColour0 = mywxCalendarDateAttr->GetBackgroundColour();
// Looking at method wxCalendarDateAttr::GetBorderColour
const wxColour retwxCalendarDateAttrGetBorderColour0 = mywxCalendarDateAttr->GetBorderColour();
// Looking at method wxCalendarDateAttr::GetFont
const wxFont retwxCalendarDateAttrGetFont0 = mywxCalendarDateAttr->GetFont();
// Looking at method wxCalendarDateAttr::GetBorder
wxCalendarDateBorder retwxCalendarDateAttrGetBorder0 = mywxCalendarDateAttr->GetBorder();

// Looking at class wxCalendarEvent
wxCalendarEvent * mywxCalendarEvent;
// Looking at method wxCalendarEvent::GetWeekDay
wxDateTime::WeekDay retwxCalendarEventGetWeekDay0 = mywxCalendarEvent->GetWeekDay();
// Looking at method wxCalendarEvent::SetWeekDay
wxDateTime::WeekDay  * wxCalendarEventSetWeekDayday0;
mywxCalendarEvent->SetWeekDay( * wxCalendarEventSetWeekDayday0);

// Looking at class wxCaret
wxCaret * mywxCaret;
// Looking at method wxCaret::wxCaret
wxCaret * newwxCaret0 = new wxCaret();
wxWindow*  * wxCaretwxCaretwindow0;
int  * wxCaretwxCaretwidth1;
int  * wxCaretwxCaretheight2;
wxCaret * newwxCaret1 = new wxCaret( * wxCaretwxCaretwindow0,  * wxCaretwxCaretwidth1,  * wxCaretwxCaretheight2);
wxWindowBase*  * wxCaretwxCaretwindow3;
wxSize  * wxCaretwxCaretsize4;
wxCaret * newwxCaret2 = new wxCaret( * wxCaretwxCaretwindow3,  * wxCaretwxCaretsize4);
// Looking at method wxCaret::Create
wxWindowBase*  * wxCaretCreatewindow0;
int  * wxCaretCreatewidth1;
int  * wxCaretCreateheight2;
bool retwxCaretCreate0 = mywxCaret->Create( * wxCaretCreatewindow0,  * wxCaretCreatewidth1,  * wxCaretCreateheight2);
wxWindowBase*  * wxCaretCreatewindow3;
wxSize  * wxCaretCreatesize4;
bool retwxCaretCreate1 = mywxCaret->Create( * wxCaretCreatewindow3,  * wxCaretCreatesize4);
// Looking at method wxCaret::GetBlinkTime
static int retwxCaretGetBlinkTime0 = mywxCaret->GetBlinkTime();
// Looking at method wxCaret::GetPosition
int*  * wxCaretGetPositionx0;
int*  * wxCaretGetPositiony1;
mywxCaret->GetPosition( * wxCaretGetPositionx0,  * wxCaretGetPositiony1);
wxPoint retwxCaretGetPosition1 = mywxCaret->GetPosition();
// Looking at method wxCaret::GetSize
int*  * wxCaretGetSizewidth0;
int*  * wxCaretGetSizeheight1;
mywxCaret->GetSize( * wxCaretGetSizewidth0,  * wxCaretGetSizeheight1);
wxSize retwxCaretGetSize1 = mywxCaret->GetSize();
// Looking at method wxCaret::GetWindow
wxWindow* retwxCaretGetWindow0 = mywxCaret->GetWindow();
// Looking at method wxCaret::Hide
mywxCaret->Hide();
// Looking at method wxCaret::IsOk
bool retwxCaretIsOk0 = mywxCaret->IsOk();
// Looking at method wxCaret::IsVisible
bool retwxCaretIsVisible0 = mywxCaret->IsVisible();
// Looking at method wxCaret::Move
int  * wxCaretMovex0;
int  * wxCaretMovey1;
mywxCaret->Move( * wxCaretMovex0,  * wxCaretMovey1);
wxPoint  * wxCaretMovept2;
mywxCaret->Move( * wxCaretMovept2);
// Looking at method wxCaret::SetBlinkTime
int  * wxCaretSetBlinkTimemilliseconds0;
mywxCaret->SetBlinkTime( * wxCaretSetBlinkTimemilliseconds0);
// Looking at method wxCaret::SetSize
int  * wxCaretSetSizewidth0;
int  * wxCaretSetSizeheight1;
mywxCaret->SetSize( * wxCaretSetSizewidth0,  * wxCaretSetSizeheight1);
wxSize  * wxCaretSetSizesize2;
mywxCaret->SetSize( * wxCaretSetSizesize2);
// Looking at method wxCaret::Show
bool  * wxCaretShowshow0;
mywxCaret->Show( * wxCaretShowshow0);

// Looking at class wxCheckBox
wxCheckBox * mywxCheckBox;
// Looking at method wxCheckBox::wxCheckBox
wxCheckBox * newwxCheckBox0 = new wxCheckBox();
wxWindow*  * wxCheckBoxwxCheckBoxparent0;
wxWindowID  * wxCheckBoxwxCheckBoxid1;
wxString  * wxCheckBoxwxCheckBoxlabel2;
wxPoint  * wxCheckBoxwxCheckBoxpos3;
wxSize  * wxCheckBoxwxCheckBoxsize4;
long  * wxCheckBoxwxCheckBoxstyle5;
wxValidator  * wxCheckBoxwxCheckBoxval6;
wxString  * wxCheckBoxwxCheckBoxname7;
wxCheckBox * newwxCheckBox1 = new wxCheckBox( * wxCheckBoxwxCheckBoxparent0,  * wxCheckBoxwxCheckBoxid1,  * wxCheckBoxwxCheckBoxlabel2,  * wxCheckBoxwxCheckBoxpos3,  * wxCheckBoxwxCheckBoxsize4,  * wxCheckBoxwxCheckBoxstyle5,  * wxCheckBoxwxCheckBoxval6,  * wxCheckBoxwxCheckBoxname7);
// Looking at method wxCheckBox::Create
wxWindow*  * wxCheckBoxCreateparent0;
wxWindowID  * wxCheckBoxCreateid1;
wxString  * wxCheckBoxCreatelabel2;
wxPoint  * wxCheckBoxCreatepos3;
wxSize  * wxCheckBoxCreatesize4;
long  * wxCheckBoxCreatestyle5;
wxValidator  * wxCheckBoxCreateval6;
wxString  * wxCheckBoxCreatename7;
bool retwxCheckBoxCreate0 = mywxCheckBox->Create( * wxCheckBoxCreateparent0,  * wxCheckBoxCreateid1,  * wxCheckBoxCreatelabel2,  * wxCheckBoxCreatepos3,  * wxCheckBoxCreatesize4,  * wxCheckBoxCreatestyle5,  * wxCheckBoxCreateval6,  * wxCheckBoxCreatename7);
// Looking at method wxCheckBox::GetValue
bool retwxCheckBoxGetValue0 = mywxCheckBox->GetValue();
// Looking at method wxCheckBox::Get3StateValue
wxCheckBoxState retwxCheckBoxGet3StateValue0 = mywxCheckBox->Get3StateValue();
// Looking at method wxCheckBox::Is3rdStateAllowedForUser
bool retwxCheckBoxIs3rdStateAllowedForUser0 = mywxCheckBox->Is3rdStateAllowedForUser();
// Looking at method wxCheckBox::Is3State
bool retwxCheckBoxIs3State0 = mywxCheckBox->Is3State();
// Looking at method wxCheckBox::IsChecked
bool retwxCheckBoxIsChecked0 = mywxCheckBox->IsChecked();
// Looking at method wxCheckBox::SetValue
bool  * wxCheckBoxSetValuestate0;
mywxCheckBox->SetValue( * wxCheckBoxSetValuestate0);
// Looking at method wxCheckBox::Set3StateValue
wxCheckBoxState  * wxCheckBoxSet3StateValuestate0;
mywxCheckBox->Set3StateValue( * wxCheckBoxSet3StateValuestate0);

// Looking at class wxCheckListBox
wxCheckListBox * mywxCheckListBox;
// Looking at method wxCheckListBox::wxCheckListBox
wxCheckListBox * newwxCheckListBox0 = new wxCheckListBox();
wxWindow*  * wxCheckListBoxwxCheckListBoxparent0;
wxWindowID  * wxCheckListBoxwxCheckListBoxid1;
wxPoint  * wxCheckListBoxwxCheckListBoxpos2;
wxSize  * wxCheckListBoxwxCheckListBoxsize3;
int  * wxCheckListBoxwxCheckListBoxn4;
wxString  * * wxCheckListBoxwxCheckListBoxchoicesptr5;
long  * wxCheckListBoxwxCheckListBoxstyle6;
wxValidator  * wxCheckListBoxwxCheckListBoxvalidator7;
wxString  * wxCheckListBoxwxCheckListBoxname8;
wxCheckListBox * newwxCheckListBox1 = new wxCheckListBox( * wxCheckListBoxwxCheckListBoxparent0,  * wxCheckListBoxwxCheckListBoxid1,  * wxCheckListBoxwxCheckListBoxpos2,  * wxCheckListBoxwxCheckListBoxsize3,  * wxCheckListBoxwxCheckListBoxn4,  * wxCheckListBoxwxCheckListBoxchoicesptr5,  * wxCheckListBoxwxCheckListBoxstyle6,  * wxCheckListBoxwxCheckListBoxvalidator7,  * wxCheckListBoxwxCheckListBoxname8);
wxWindow*  * wxCheckListBoxwxCheckListBoxparent9;
wxWindowID  * wxCheckListBoxwxCheckListBoxid10;
wxPoint  * wxCheckListBoxwxCheckListBoxpos11;
wxSize  * wxCheckListBoxwxCheckListBoxsize12;
wxArrayString  * wxCheckListBoxwxCheckListBoxchoices13;
long  * wxCheckListBoxwxCheckListBoxstyle14;
wxValidator  * wxCheckListBoxwxCheckListBoxvalidator15;
wxString  * wxCheckListBoxwxCheckListBoxname16;
wxCheckListBox * newwxCheckListBox2 = new wxCheckListBox( * wxCheckListBoxwxCheckListBoxparent9,  * wxCheckListBoxwxCheckListBoxid10,  * wxCheckListBoxwxCheckListBoxpos11,  * wxCheckListBoxwxCheckListBoxsize12,  * wxCheckListBoxwxCheckListBoxchoices13,  * wxCheckListBoxwxCheckListBoxstyle14,  * wxCheckListBoxwxCheckListBoxvalidator15,  * wxCheckListBoxwxCheckListBoxname16);
// Looking at method wxCheckListBox::Check
int  * wxCheckListBoxCheckitem0;
bool  * wxCheckListBoxCheckcheck1;
mywxCheckListBox->Check( * wxCheckListBoxCheckitem0,  * wxCheckListBoxCheckcheck1);
// Looking at method wxCheckListBox::IsChecked
int  * wxCheckListBoxIsCheckeditem0;
bool retwxCheckListBoxIsChecked0 = mywxCheckListBox->IsChecked( * wxCheckListBoxIsCheckeditem0);

// Looking at class wxChoice
wxChoice * mywxChoice;
// Looking at method wxChoice::wxChoice
wxChoice * newwxChoice0 = new wxChoice();
wxWindow * * wxChoicewxChoiceparent0;
wxWindowID  * wxChoicewxChoiceid1;
wxPoint  * wxChoicewxChoicepos2;
wxSize  * wxChoicewxChoicesize3;
int  * wxChoicewxChoicen4;
wxString  * * wxChoicewxChoicechoicesptr5;
long  * wxChoicewxChoicestyle6;
wxValidator  * wxChoicewxChoicevalidator7;
wxString  * wxChoicewxChoicename8;
wxChoice * newwxChoice1 = new wxChoice( * wxChoicewxChoiceparent0,  * wxChoicewxChoiceid1,  * wxChoicewxChoicepos2,  * wxChoicewxChoicesize3,  * wxChoicewxChoicen4,  * wxChoicewxChoicechoicesptr5,  * wxChoicewxChoicestyle6,  * wxChoicewxChoicevalidator7,  * wxChoicewxChoicename8);
wxWindow * * wxChoicewxChoiceparent9;
wxWindowID  * wxChoicewxChoiceid10;
wxPoint  * wxChoicewxChoicepos11;
wxSize  * wxChoicewxChoicesize12;
wxArrayString  * wxChoicewxChoicechoices13;
long  * wxChoicewxChoicestyle14;
wxValidator  * wxChoicewxChoicevalidator15;
wxString  * wxChoicewxChoicename16;
wxChoice * newwxChoice2 = new wxChoice( * wxChoicewxChoiceparent9,  * wxChoicewxChoiceid10,  * wxChoicewxChoicepos11,  * wxChoicewxChoicesize12,  * wxChoicewxChoicechoices13,  * wxChoicewxChoicestyle14,  * wxChoicewxChoicevalidator15,  * wxChoicewxChoicename16);
// Looking at method wxChoice::Create
wxWindow * * wxChoiceCreateparent0;
wxWindowID  * wxChoiceCreateid1;
wxPoint  * wxChoiceCreatepos2;
wxSize  * wxChoiceCreatesize3;
int  * wxChoiceCreaten4;
wxString  * * wxChoiceCreatechoicesptr5;
long  * wxChoiceCreatestyle6;
wxValidator  * wxChoiceCreatevalidator7;
wxString  * wxChoiceCreatename8;
bool retwxChoiceCreate0 = mywxChoice->Create( * wxChoiceCreateparent0,  * wxChoiceCreateid1,  * wxChoiceCreatepos2,  * wxChoiceCreatesize3,  * wxChoiceCreaten4,  * wxChoiceCreatechoicesptr5,  * wxChoiceCreatestyle6,  * wxChoiceCreatevalidator7,  * wxChoiceCreatename8);
wxWindow * * wxChoiceCreateparent9;
wxWindowID  * wxChoiceCreateid10;
wxPoint  * wxChoiceCreatepos11;
wxSize  * wxChoiceCreatesize12;
wxArrayString  * wxChoiceCreatechoices13;
long  * wxChoiceCreatestyle14;
wxValidator  * wxChoiceCreatevalidator15;
wxString  * wxChoiceCreatename16;
bool retwxChoiceCreate1 = mywxChoice->Create( * wxChoiceCreateparent9,  * wxChoiceCreateid10,  * wxChoiceCreatepos11,  * wxChoiceCreatesize12,  * wxChoiceCreatechoices13,  * wxChoiceCreatestyle14,  * wxChoiceCreatevalidator15,  * wxChoiceCreatename16);
// Looking at method wxChoice::Delete
int  * wxChoiceDeleten0;
mywxChoice->Delete( * wxChoiceDeleten0);
// Looking at method wxChoice::GetColumns
int retwxChoiceGetColumns0 = mywxChoice->GetColumns();
// Looking at method wxChoice::SetColumns
int  * wxChoiceSetColumnsn0;
mywxChoice->SetColumns( * wxChoiceSetColumnsn0);

// Looking at class wxChoicebook
wxChoicebook * mywxChoicebook;

// Looking at class wxClassInfo
wxClassInfo * mywxClassInfo;
// Looking at method wxClassInfo::wxClassInfo
wxChar *  * wxClassInfowxClassInfoclassName0;
wxClassInfo *  * wxClassInfowxClassInfobaseClass11;
wxClassInfo *  * wxClassInfowxClassInfobaseClass22;
int  * wxClassInfowxClassInfosize3;
wxObjectConstructorFn  * wxClassInfowxClassInfofn4;
wxClassInfo * newwxClassInfo0 = new wxClassInfo( * wxClassInfowxClassInfoclassName0,  * wxClassInfowxClassInfobaseClass11,  * wxClassInfowxClassInfobaseClass22,  * wxClassInfowxClassInfosize3,  * wxClassInfowxClassInfofn4);
// Looking at method wxClassInfo::CreateObject
wxObject* retwxClassInfoCreateObject0 = mywxClassInfo->CreateObject();
// Looking at method wxClassInfo::FindClass
wxChar *  * wxClassInfoFindClassname0;
static wxClassInfo * retwxClassInfoFindClass0 = mywxClassInfo->FindClass( * wxClassInfoFindClassname0);
// Looking at method wxClassInfo::GetBaseClassName1
const wxChar * retwxClassInfoGetBaseClassName10 = mywxClassInfo->GetBaseClassName1();
// Looking at method wxClassInfo::GetBaseClassName2
const wxChar * retwxClassInfoGetBaseClassName20 = mywxClassInfo->GetBaseClassName2();
// Looking at method wxClassInfo::GetClassName
const wxChar * retwxClassInfoGetClassName0 = mywxClassInfo->GetClassName();
// Looking at method wxClassInfo::GetSize
int retwxClassInfoGetSize0 = mywxClassInfo->GetSize();
// Looking at method wxClassInfo::InitializeClasses
mywxClassInfo->InitializeClasses();
// Looking at method wxClassInfo::IsKindOf
wxClassInfo*  * wxClassInfoIsKindOfinfo0;
bool retwxClassInfoIsKindOf0 = mywxClassInfo->IsKindOf( * wxClassInfoIsKindOfinfo0);

// Looking at class wxClient
wxClient * mywxClient;
// Looking at method wxClient::wxClient
wxClient * newwxClient0 = new wxClient();
// Looking at method wxClient::MakeConnection
wxString  * wxClientMakeConnectionhost0;
wxString  * wxClientMakeConnectionservice1;
wxString  * wxClientMakeConnectiontopic2;
wxConnectionBase * retwxClientMakeConnection0 = mywxClient->MakeConnection( * wxClientMakeConnectionhost0,  * wxClientMakeConnectionservice1,  * wxClientMakeConnectiontopic2);
// Looking at method wxClient::OnMakeConnection
wxConnectionBase * retwxClientOnMakeConnection0 = mywxClient->OnMakeConnection();
// Looking at method wxClient::ValidHost
wxString  * wxClientValidHosthost0;
bool retwxClientValidHost0 = mywxClient->ValidHost( * wxClientValidHosthost0);

// Looking at class wxClientDC
wxClientDC * mywxClientDC;
// Looking at method wxClientDC::wxClientDC
wxWindow*  * wxClientDCwxClientDCwindow0;
wxClientDC * newwxClientDC0 = new wxClientDC( * wxClientDCwxClientDCwindow0);

// Looking at class wxClientData
wxClientData * mywxClientData;
// Looking at method wxClientData::wxClientData
wxClientData * newwxClientData0 = new wxClientData();

// Looking at class wxClientDataContainer
wxClientDataContainer * mywxClientDataContainer;
// Looking at method wxClientDataContainer::wxClientDataContainer
wxClientDataContainer * newwxClientDataContainer0 = new wxClientDataContainer();
// Looking at method wxClientDataContainer::GetClientData
mywxClientDataContainer->GetClientData();
// Looking at method wxClientDataContainer::GetClientObject
wxClientData* retwxClientDataContainerGetClientObject0 = mywxClientDataContainer->GetClientObject();
// Looking at method wxClientDataContainer::SetClientData
void*  * wxClientDataContainerSetClientDatadata0;
mywxClientDataContainer->SetClientData( * wxClientDataContainerSetClientDatadata0);
// Looking at method wxClientDataContainer::SetClientObject
wxClientData*  * wxClientDataContainerSetClientObjectdata0;
mywxClientDataContainer->SetClientObject( * wxClientDataContainerSetClientObjectdata0);

// Looking at class wxClipboard
wxClipboard * mywxClipboard;
// Looking at method wxClipboard::wxClipboard
wxClipboard * newwxClipboard0 = new wxClipboard();
// Looking at method wxClipboard::AddData
wxDataObject*  * wxClipboardAddDatadata0;
bool retwxClipboardAddData0 = mywxClipboard->AddData( * wxClipboardAddDatadata0);
// Looking at method wxClipboard::Clear
mywxClipboard->Clear();
// Looking at method wxClipboard::Close
mywxClipboard->Close();
// Looking at method wxClipboard::Flush
bool retwxClipboardFlush0 = mywxClipboard->Flush();
// Looking at method wxClipboard::GetData
wxDataObject  * wxClipboardGetDatadata0;
bool retwxClipboardGetData0 = mywxClipboard->GetData( * wxClipboardGetDatadata0);
// Looking at method wxClipboard::IsOpened
bool retwxClipboardIsOpened0 = mywxClipboard->IsOpened();
// Looking at method wxClipboard::IsSupported
wxDataFormat  * wxClipboardIsSupportedformat0;
bool retwxClipboardIsSupported0 = mywxClipboard->IsSupported( * wxClipboardIsSupportedformat0);
// Looking at method wxClipboard::Open
bool retwxClipboardOpen0 = mywxClipboard->Open();
// Looking at method wxClipboard::SetData
wxDataObject*  * wxClipboardSetDatadata0;
bool retwxClipboardSetData0 = mywxClipboard->SetData( * wxClipboardSetDatadata0);
// Looking at method wxClipboard::UsePrimarySelection
bool  * wxClipboardUsePrimarySelectionprimary0;
mywxClipboard->UsePrimarySelection( * wxClipboardUsePrimarySelectionprimary0);

// Looking at class wxCloseEvent
wxCloseEvent * mywxCloseEvent;
// Looking at method wxCloseEvent::wxCloseEvent
WXTYPE  * wxCloseEventwxCloseEventcommandEventType0;
int  * wxCloseEventwxCloseEventid1;
wxCloseEvent * newwxCloseEvent0 = new wxCloseEvent( * wxCloseEventwxCloseEventcommandEventType0,  * wxCloseEventwxCloseEventid1);
// Looking at method wxCloseEvent::CanVeto
bool retwxCloseEventCanVeto0 = mywxCloseEvent->CanVeto();
// Looking at method wxCloseEvent::GetLoggingOff
bool retwxCloseEventGetLoggingOff0 = mywxCloseEvent->GetLoggingOff();
// Looking at method wxCloseEvent::GetForce
// Looking at method wxCloseEvent::SetCanVeto
bool  * wxCloseEventSetCanVetocanVeto0;
mywxCloseEvent->SetCanVeto( * wxCloseEventSetCanVetocanVeto0);
// Looking at method wxCloseEvent::SetForce
// Looking at method wxCloseEvent::SetLoggingOff
bool  * wxCloseEventSetLoggingOffloggingOff0;
mywxCloseEvent->SetLoggingOff( * wxCloseEventSetLoggingOffloggingOff0);
// Looking at method wxCloseEvent::Veto
bool  * wxCloseEventVetoveto0;
mywxCloseEvent->Veto( * wxCloseEventVetoveto0);

// Looking at class wxColour
wxColour * mywxColour;
// Looking at method wxColour::wxColour
wxColour * newwxColour0 = new wxColour();
unsigned char  * wxColourwxColourred0;
unsigned char  * wxColourwxColourgreen1;
unsigned char  * wxColourwxColourblue2;
wxColour * newwxColour1 = new wxColour( * wxColourwxColourred0,  * wxColourwxColourgreen1,  * wxColourwxColourblue2);
wxString  * wxColourwxColourcolourNname3;
wxColour * newwxColour2 = new wxColour( * wxColourwxColourcolourNname3);
wxColour  * wxColourwxColourcolour4;
wxColour * newwxColour3 = new wxColour( * wxColourwxColourcolour4);
// Looking at method wxColour::Blue
unsigned char retwxColourBlue0 = mywxColour->Blue();
// Looking at method wxColour::GetPixel
long retwxColourGetPixel0 = mywxColour->GetPixel();
// Looking at method wxColour::Green
unsigned char retwxColourGreen0 = mywxColour->Green();
// Looking at method wxColour::Ok
bool retwxColourOk0 = mywxColour->Ok();
// Looking at method wxColour::Red
unsigned char retwxColourRed0 = mywxColour->Red();
// Looking at method wxColour::Set
unsigned char  * wxColourSetred0;
unsigned char  * wxColourSetgreen1;
unsigned char  * wxColourSetblue2;
mywxColour->Set( * wxColourSetred0,  * wxColourSetgreen1,  * wxColourSetblue2);

// Looking at class wxColourData
wxColourData * mywxColourData;
// Looking at method wxColourData::wxColourData
wxColourData * newwxColourData0 = new wxColourData();
// Looking at method wxColourData::GetChooseFull
bool retwxColourDataGetChooseFull0 = mywxColourData->GetChooseFull();
// Looking at method wxColourData::GetColour
wxColour retwxColourDataGetColour0 = mywxColourData->GetColour();
// Looking at method wxColourData::GetCustomColour
int  * wxColourDataGetCustomColouri0;
wxColour retwxColourDataGetCustomColour0 = mywxColourData->GetCustomColour( * wxColourDataGetCustomColouri0);
// Looking at method wxColourData::SetChooseFull
bool  * wxColourDataSetChooseFullflag0;
mywxColourData->SetChooseFull( * wxColourDataSetChooseFullflag0);
// Looking at method wxColourData::SetColour
wxColour  * wxColourDataSetColourcolour0;
mywxColourData->SetColour( * wxColourDataSetColourcolour0);
// Looking at method wxColourData::SetCustomColour
int  * wxColourDataSetCustomColouri0;
wxColour  * wxColourDataSetCustomColourcolour1;
mywxColourData->SetCustomColour( * wxColourDataSetCustomColouri0,  * wxColourDataSetCustomColourcolour1);

// Looking at class wxColourDatabase
wxColourDatabase * mywxColourDatabase;
// Looking at method wxColourDatabase::wxColourDatabase
wxColourDatabase * newwxColourDatabase0 = new wxColourDatabase();
// Looking at method wxColourDatabase::AddColour
wxString  * wxColourDatabaseAddColourcolourName0;
wxColour * wxColourDatabaseAddColourcolour1;
mywxColourDatabase->AddColour( * wxColourDatabaseAddColourcolourName0,  * wxColourDatabaseAddColourcolour1);
// Looking at method wxColourDatabase::Find
wxString  * wxColourDatabaseFindcolourName0;
wxColour retwxColourDatabaseFind0 = mywxColourDatabase->Find( * wxColourDatabaseFindcolourName0);
// Looking at method wxColourDatabase::FindName
wxColour  * wxColourDatabaseFindNamecolour0;
wxString retwxColourDatabaseFindName0 = mywxColourDatabase->FindName( * wxColourDatabaseFindNamecolour0);

// Looking at class wxColourDialog
wxColourDialog * mywxColourDialog;
// Looking at method wxColourDialog::wxColourDialog
wxWindow*  * wxColourDialogwxColourDialogparent0;
wxColourData*  * wxColourDialogwxColourDialogdata1;
wxColourDialog * newwxColourDialog0 = new wxColourDialog( * wxColourDialogwxColourDialogparent0,  * wxColourDialogwxColourDialogdata1);
// Looking at method wxColourDialog::Create
wxWindow*  * wxColourDialogCreateparent0;
wxColourData*  * wxColourDialogCreatedata1;
bool retwxColourDialogCreate0 = mywxColourDialog->Create( * wxColourDialogCreateparent0,  * wxColourDialogCreatedata1);
// Looking at method wxColourDialog::GetColourData
wxColourData retwxColourDialogGetColourData0 = mywxColourDialog->GetColourData();
// Looking at method wxColourDialog::ShowModal
int retwxColourDialogShowModal0 = mywxColourDialog->ShowModal();

// Looking at class wxComboBox
wxComboBox * mywxComboBox;
// Looking at method wxComboBox::wxComboBox
wxComboBox * newwxComboBox0 = new wxComboBox();
wxWindow*  * wxComboBoxwxComboBoxparent0;
wxWindowID  * wxComboBoxwxComboBoxid1;
wxString  * wxComboBoxwxComboBoxvalue2;
wxPoint  * wxComboBoxwxComboBoxpos3;
wxSize  * wxComboBoxwxComboBoxsize4;
int  * wxComboBoxwxComboBoxn5;
wxString  * * wxComboBoxwxComboBoxchoicesptr6;
long  * wxComboBoxwxComboBoxstyle7;
wxValidator  * wxComboBoxwxComboBoxvalidator8;
wxString  * wxComboBoxwxComboBoxname9;
wxComboBox * newwxComboBox1 = new wxComboBox( * wxComboBoxwxComboBoxparent0,  * wxComboBoxwxComboBoxid1,  * wxComboBoxwxComboBoxvalue2,  * wxComboBoxwxComboBoxpos3,  * wxComboBoxwxComboBoxsize4,  * wxComboBoxwxComboBoxn5,  * wxComboBoxwxComboBoxchoicesptr6,  * wxComboBoxwxComboBoxstyle7,  * wxComboBoxwxComboBoxvalidator8,  * wxComboBoxwxComboBoxname9);
wxWindow*  * wxComboBoxwxComboBoxparent10;
wxWindowID  * wxComboBoxwxComboBoxid11;
wxString  * wxComboBoxwxComboBoxvalue12;
wxPoint  * wxComboBoxwxComboBoxpos13;
wxSize  * wxComboBoxwxComboBoxsize14;
wxArrayString  * wxComboBoxwxComboBoxchoices15;
long  * wxComboBoxwxComboBoxstyle16;
wxValidator  * wxComboBoxwxComboBoxvalidator17;
wxString  * wxComboBoxwxComboBoxname18;
wxComboBox * newwxComboBox2 = new wxComboBox( * wxComboBoxwxComboBoxparent10,  * wxComboBoxwxComboBoxid11,  * wxComboBoxwxComboBoxvalue12,  * wxComboBoxwxComboBoxpos13,  * wxComboBoxwxComboBoxsize14,  * wxComboBoxwxComboBoxchoices15,  * wxComboBoxwxComboBoxstyle16,  * wxComboBoxwxComboBoxvalidator17,  * wxComboBoxwxComboBoxname18);
// Looking at method wxComboBox::Create
wxWindow*  * wxComboBoxCreateparent0;
wxWindowID  * wxComboBoxCreateid1;
wxString  * wxComboBoxCreatevalue2;
wxPoint  * wxComboBoxCreatepos3;
wxSize  * wxComboBoxCreatesize4;
int  * wxComboBoxCreaten5;
wxString  * * wxComboBoxCreatechoicesptr6;
long  * wxComboBoxCreatestyle7;
wxValidator  * wxComboBoxCreatevalidator8;
wxString  * wxComboBoxCreatename9;
bool retwxComboBoxCreate0 = mywxComboBox->Create( * wxComboBoxCreateparent0,  * wxComboBoxCreateid1,  * wxComboBoxCreatevalue2,  * wxComboBoxCreatepos3,  * wxComboBoxCreatesize4,  * wxComboBoxCreaten5,  * wxComboBoxCreatechoicesptr6,  * wxComboBoxCreatestyle7,  * wxComboBoxCreatevalidator8,  * wxComboBoxCreatename9);
wxWindow*  * wxComboBoxCreateparent10;
wxWindowID  * wxComboBoxCreateid11;
wxString  * wxComboBoxCreatevalue12;
wxPoint  * wxComboBoxCreatepos13;
wxSize  * wxComboBoxCreatesize14;
wxArrayString  * wxComboBoxCreatechoices15;
long  * wxComboBoxCreatestyle16;
wxValidator  * wxComboBoxCreatevalidator17;
wxString  * wxComboBoxCreatename18;
bool retwxComboBoxCreate1 = mywxComboBox->Create( * wxComboBoxCreateparent10,  * wxComboBoxCreateid11,  * wxComboBoxCreatevalue12,  * wxComboBoxCreatepos13,  * wxComboBoxCreatesize14,  * wxComboBoxCreatechoices15,  * wxComboBoxCreatestyle16,  * wxComboBoxCreatevalidator17,  * wxComboBoxCreatename18);
// Looking at method wxComboBox::CanCopy
bool retwxComboBoxCanCopy0 = mywxComboBox->CanCopy();
// Looking at method wxComboBox::CanCut
bool retwxComboBoxCanCut0 = mywxComboBox->CanCut();
// Looking at method wxComboBox::CanPaste
bool retwxComboBoxCanPaste0 = mywxComboBox->CanPaste();
// Looking at method wxComboBox::CanRedo
bool retwxComboBoxCanRedo0 = mywxComboBox->CanRedo();
// Looking at method wxComboBox::CanUndo
bool retwxComboBoxCanUndo0 = mywxComboBox->CanUndo();
// Looking at method wxComboBox::Copy
mywxComboBox->Copy();
// Looking at method wxComboBox::Cut
mywxComboBox->Cut();
// Looking at method wxComboBox::GetInsertionPoint
long retwxComboBoxGetInsertionPoint0 = mywxComboBox->GetInsertionPoint();
// Looking at method wxComboBox::GetLastPosition
// Looking at method wxComboBox::GetValue
wxString retwxComboBoxGetValue0 = mywxComboBox->GetValue();
// Looking at method wxComboBox::Paste
mywxComboBox->Paste();
// Looking at method wxComboBox::Redo
mywxComboBox->Redo();
// Looking at method wxComboBox::Replace
long  * wxComboBoxReplacefrom0;
long  * wxComboBoxReplaceto1;
wxString  * wxComboBoxReplacetext2;
mywxComboBox->Replace( * wxComboBoxReplacefrom0,  * wxComboBoxReplaceto1,  * wxComboBoxReplacetext2);
// Looking at method wxComboBox::Remove
long  * wxComboBoxRemovefrom0;
long  * wxComboBoxRemoveto1;
mywxComboBox->Remove( * wxComboBoxRemovefrom0,  * wxComboBoxRemoveto1);
// Looking at method wxComboBox::SetInsertionPoint
long  * wxComboBoxSetInsertionPointpos0;
mywxComboBox->SetInsertionPoint( * wxComboBoxSetInsertionPointpos0);
// Looking at method wxComboBox::SetInsertionPointEnd
mywxComboBox->SetInsertionPointEnd();
// Looking at method wxComboBox::SetSelection
long  * wxComboBoxSetSelectionfrom0;
long  * wxComboBoxSetSelectionto1;
mywxComboBox->SetSelection( * wxComboBoxSetSelectionfrom0,  * wxComboBoxSetSelectionto1);
// Looking at method wxComboBox::SetValue
wxString  * wxComboBoxSetValuetext0;
mywxComboBox->SetValue( * wxComboBoxSetValuetext0);
// Looking at method wxComboBox::Undo
mywxComboBox->Undo();

// Looking at class wxCommandEvent
wxCommandEvent * mywxCommandEvent;
// Looking at method wxCommandEvent::m_clientData
// Looking at method wxCommandEvent::m_commandInt
// Looking at method wxCommandEvent::m_commandString
// Looking at method wxCommandEvent::m_extraLong
// Looking at method wxCommandEvent::wxCommandEvent
WXTYPE  * wxCommandEventwxCommandEventcommandEventType0;
int  * wxCommandEventwxCommandEventid1;
wxCommandEvent * newwxCommandEvent0 = new wxCommandEvent( * wxCommandEventwxCommandEventcommandEventType0,  * wxCommandEventwxCommandEventid1);
// Looking at method wxCommandEvent::Checked
// Looking at method wxCommandEvent::GetClientData
mywxCommandEvent->GetClientData();
// Looking at method wxCommandEvent::GetClientObject
wxClientData * retwxCommandEventGetClientObject0 = mywxCommandEvent->GetClientObject();
// Looking at method wxCommandEvent::GetExtraLong
long retwxCommandEventGetExtraLong0 = mywxCommandEvent->GetExtraLong();
// Looking at method wxCommandEvent::GetInt
int retwxCommandEventGetInt0 = mywxCommandEvent->GetInt();
// Looking at method wxCommandEvent::GetSelection
int retwxCommandEventGetSelection0 = mywxCommandEvent->GetSelection();
// Looking at method wxCommandEvent::GetString
wxString retwxCommandEventGetString0 = mywxCommandEvent->GetString();
// Looking at method wxCommandEvent::IsChecked
bool retwxCommandEventIsChecked0 = mywxCommandEvent->IsChecked();
// Looking at method wxCommandEvent::IsSelection
bool retwxCommandEventIsSelection0 = mywxCommandEvent->IsSelection();
// Looking at method wxCommandEvent::SetClientData
void*  * wxCommandEventSetClientDataclientData0;
mywxCommandEvent->SetClientData( * wxCommandEventSetClientDataclientData0);
// Looking at method wxCommandEvent::SetClientObject
wxClientData*  * wxCommandEventSetClientObjectclientObject0;
mywxCommandEvent->SetClientObject( * wxCommandEventSetClientObjectclientObject0);
// Looking at method wxCommandEvent::SetExtraLong
int  * wxCommandEventSetExtraLongextraLong0;
mywxCommandEvent->SetExtraLong( * wxCommandEventSetExtraLongextraLong0);
// Looking at method wxCommandEvent::SetInt
int  * wxCommandEventSetIntintCommand0;
mywxCommandEvent->SetInt( * wxCommandEventSetIntintCommand0);
// Looking at method wxCommandEvent::SetString
wxString  * wxCommandEventSetStringstring0;
mywxCommandEvent->SetString( * wxCommandEventSetStringstring0);

// Looking at class wxCommandProcessor
wxCommandProcessor * mywxCommandProcessor;
// Looking at method wxCommandProcessor::wxCommandProcessor
int  * wxCommandProcessorwxCommandProcessormaxCommands0;
wxCommandProcessor * newwxCommandProcessor0 = new wxCommandProcessor( * wxCommandProcessorwxCommandProcessormaxCommands0);
// Looking at method wxCommandProcessor::CanUndo
// Looking at method wxCommandProcessor::ClearCommands
// Looking at method wxCommandProcessor::Redo
// Looking at method wxCommandProcessor::GetCommands
wxList retwxCommandProcessorGetCommands0 = mywxCommandProcessor->GetCommands();
// Looking at method wxCommandProcessor::GetMaxCommands
int retwxCommandProcessorGetMaxCommands0 = mywxCommandProcessor->GetMaxCommands();
// Looking at method wxCommandProcessor::GetEditMenu
wxMenu* retwxCommandProcessorGetEditMenu0 = mywxCommandProcessor->GetEditMenu();
// Looking at method wxCommandProcessor::GetRedoAccelerator
const wxString retwxCommandProcessorGetRedoAccelerator0 = mywxCommandProcessor->GetRedoAccelerator();
// Looking at method wxCommandProcessor::GetRedoMenuLabel
wxString retwxCommandProcessorGetRedoMenuLabel0 = mywxCommandProcessor->GetRedoMenuLabel();
// Looking at method wxCommandProcessor::GetUndoAccelerator
const wxString retwxCommandProcessorGetUndoAccelerator0 = mywxCommandProcessor->GetUndoAccelerator();
// Looking at method wxCommandProcessor::GetUndoMenuLabel
wxString retwxCommandProcessorGetUndoMenuLabel0 = mywxCommandProcessor->GetUndoMenuLabel();
// Looking at method wxCommandProcessor::Initialize
// Looking at method wxCommandProcessor::IsDirty
// Looking at method wxCommandProcessor::MarkAsSaved
// Looking at method wxCommandProcessor::SetEditMenu
wxMenu*  * wxCommandProcessorSetEditMenumenu0;
mywxCommandProcessor->SetEditMenu( * wxCommandProcessorSetEditMenumenu0);
// Looking at method wxCommandProcessor::SetMenuStrings
mywxCommandProcessor->SetMenuStrings();
// Looking at method wxCommandProcessor::SetRedoAccelerator
wxString * wxCommandProcessorSetRedoAcceleratoraccel0;
mywxCommandProcessor->SetRedoAccelerator( * wxCommandProcessorSetRedoAcceleratoraccel0);
// Looking at method wxCommandProcessor::SetUndoAccelerator
wxString * wxCommandProcessorSetUndoAcceleratoraccel0;
mywxCommandProcessor->SetUndoAccelerator( * wxCommandProcessorSetUndoAcceleratoraccel0);
// Looking at method wxCommandProcessor::Submit
// Looking at method wxCommandProcessor::Undo

// Looking at class wxCondition
wxCondition * mywxCondition;
// Looking at method wxCondition::wxCondition
wxMutex  * wxConditionwxConditionmutex0;
wxCondition * newwxCondition0 = new wxCondition( * wxConditionwxConditionmutex0);
// Looking at method wxCondition::Broadcast
mywxCondition->Broadcast();
// Looking at method wxCondition::IsOk
bool retwxConditionIsOk0 = mywxCondition->IsOk();
// Looking at method wxCondition::Signal
mywxCondition->Signal();
// Looking at method wxCondition::Wait
wxCondError retwxConditionWait0 = mywxCondition->Wait();
// Looking at method wxCondition::WaitTimeout
unsigned long  * wxConditionWaitTimeoutmilliseconds0;
wxCondError retwxConditionWaitTimeout0 = mywxCondition->WaitTimeout( * wxConditionWaitTimeoutmilliseconds0);

// Looking at class wxConnection
wxConnection * mywxConnection;
// Looking at method wxConnection::wxConnection
wxConnection * newwxConnection0 = new wxConnection();
char*  * wxConnectionwxConnectionbuffer0;
int  * wxConnectionwxConnectionsize1;
wxConnection * newwxConnection1 = new wxConnection( * wxConnectionwxConnectionbuffer0,  * wxConnectionwxConnectionsize1);
// Looking at method wxConnection::Advise
wxString  * wxConnectionAdviseitem0;
char*  * wxConnectionAdvisedata1;
int  * wxConnectionAdvisesize2;
wxIPCFormat  * wxConnectionAdviseformat3;
bool retwxConnectionAdvise0 = mywxConnection->Advise( * wxConnectionAdviseitem0,  * wxConnectionAdvisedata1,  * wxConnectionAdvisesize2,  * wxConnectionAdviseformat3);
// Looking at method wxConnection::Execute
char*  * wxConnectionExecutedata0;
int  * wxConnectionExecutesize1;
wxIPCFormat  * wxConnectionExecuteformat2;
bool retwxConnectionExecute0 = mywxConnection->Execute( * wxConnectionExecutedata0,  * wxConnectionExecutesize1,  * wxConnectionExecuteformat2);
// Looking at method wxConnection::Disconnect
bool retwxConnectionDisconnect0 = mywxConnection->Disconnect();
// Looking at method wxConnection::OnAdvise
// Looking at method wxConnection::OnDisconnect
// Looking at method wxConnection::OnExecute
// Looking at method wxConnection::OnPoke
// Looking at method wxConnection::OnRequest
// Looking at method wxConnection::OnStartAdvise
// Looking at method wxConnection::OnStopAdvise
// Looking at method wxConnection::Poke
wxString  * wxConnectionPokeitem0;
char*  * wxConnectionPokedata1;
int  * wxConnectionPokesize2;
wxIPCFormat  * wxConnectionPokeformat3;
bool retwxConnectionPoke0 = mywxConnection->Poke( * wxConnectionPokeitem0,  * wxConnectionPokedata1,  * wxConnectionPokesize2,  * wxConnectionPokeformat3);
// Looking at method wxConnection::Request
wxString  * wxConnectionRequestitem0;
int * * wxConnectionRequestsize1;
wxIPCFormat  * wxConnectionRequestformat2;
char* retwxConnectionRequest0 = mywxConnection->Request( * wxConnectionRequestitem0,  * wxConnectionRequestsize1,  * wxConnectionRequestformat2);
// Looking at method wxConnection::StartAdvise
wxString  * wxConnectionStartAdviseitem0;
bool retwxConnectionStartAdvise0 = mywxConnection->StartAdvise( * wxConnectionStartAdviseitem0);
// Looking at method wxConnection::StopAdvise
wxString  * wxConnectionStopAdviseitem0;
bool retwxConnectionStopAdvise0 = mywxConnection->StopAdvise( * wxConnectionStopAdviseitem0);

// Looking at class wxContextHelp
wxContextHelp * mywxContextHelp;
// Looking at method wxContextHelp::wxContextHelp
wxWindow*  * wxContextHelpwxContextHelpwindow0;
bool  * wxContextHelpwxContextHelpdoNow1;
wxContextHelp * newwxContextHelp0 = new wxContextHelp( * wxContextHelpwxContextHelpwindow0,  * wxContextHelpwxContextHelpdoNow1);
// Looking at method wxContextHelp::BeginContextHelp
wxWindow*  * wxContextHelpBeginContextHelpwindow0;
bool retwxContextHelpBeginContextHelp0 = mywxContextHelp->BeginContextHelp( * wxContextHelpBeginContextHelpwindow0);
// Looking at method wxContextHelp::EndContextHelp
bool retwxContextHelpEndContextHelp0 = mywxContextHelp->EndContextHelp();

// Looking at class wxContextMenuEvent
wxContextMenuEvent * mywxContextMenuEvent;
// Looking at method wxContextMenuEvent::wxContextMenuEvent
WXTYPE  * wxContextMenuEventwxContextMenuEventid0;
int  * wxContextMenuEventwxContextMenuEventid1;
wxPoint  * wxContextMenuEventwxContextMenuEventpos2;
wxContextMenuEvent * newwxContextMenuEvent0 = new wxContextMenuEvent( * wxContextMenuEventwxContextMenuEventid0,  * wxContextMenuEventwxContextMenuEventid1,  * wxContextMenuEventwxContextMenuEventpos2);
// Looking at method wxContextMenuEvent::GetPosition
wxPoint retwxContextMenuEventGetPosition0 = mywxContextMenuEvent->GetPosition();
// Looking at method wxContextMenuEvent::SetPosition
wxPoint  * wxContextMenuEventSetPositionpoint0;
mywxContextMenuEvent->SetPosition( * wxContextMenuEventSetPositionpoint0);

// Looking at class wxControl
wxControl * mywxControl;
// Looking at method wxControl::Command
wxCommandEvent  * wxControlCommandevent0;
mywxControl->Command( * wxControlCommandevent0);
// Looking at method wxControl::GetLabel
wxString retwxControlGetLabel0 = mywxControl->GetLabel();
// Looking at method wxControl::SetLabel
wxString  * wxControlSetLabellabel0;
mywxControl->SetLabel( * wxControlSetLabellabel0);

// Looking at class wxControlWithItems
wxControlWithItems * mywxControlWithItems;
// Looking at method wxControlWithItems::Append
wxString   * wxControlWithItemsAppenditem0;
int retwxControlWithItemsAppend0 = mywxControlWithItems->Append( * wxControlWithItemsAppenditem0);
wxString   * wxControlWithItemsAppenditem1;
void * * wxControlWithItemsAppendclientData2;
int retwxControlWithItemsAppend1 = mywxControlWithItems->Append( * wxControlWithItemsAppenditem1,  * wxControlWithItemsAppendclientData2);
wxString   * wxControlWithItemsAppenditem3;
wxClientData * * wxControlWithItemsAppendclientData4;
int retwxControlWithItemsAppend2 = mywxControlWithItems->Append( * wxControlWithItemsAppenditem3,  * wxControlWithItemsAppendclientData4);
wxArrayString  * wxControlWithItemsAppendstrings5;
mywxControlWithItems->Append( * wxControlWithItemsAppendstrings5);
// Looking at method wxControlWithItems::Clear
mywxControlWithItems->Clear();
// Looking at method wxControlWithItems::Delete
int  * wxControlWithItemsDeleten0;
mywxControlWithItems->Delete( * wxControlWithItemsDeleten0);
// Looking at method wxControlWithItems::FindString
wxString  * wxControlWithItemsFindStringstring0;
int retwxControlWithItemsFindString0 = mywxControlWithItems->FindString( * wxControlWithItemsFindStringstring0);
// Looking at method wxControlWithItems::GetClientData
int  * wxControlWithItemsGetClientDatan0;
mywxControlWithItems->GetClientData( * wxControlWithItemsGetClientDatan0);
// Looking at method wxControlWithItems::GetClientObject
int  * wxControlWithItemsGetClientObjectn0;
wxClientData * retwxControlWithItemsGetClientObject0 = mywxControlWithItems->GetClientObject( * wxControlWithItemsGetClientObjectn0);
// Looking at method wxControlWithItems::GetCount
int retwxControlWithItemsGetCount0 = mywxControlWithItems->GetCount();
// Looking at method wxControlWithItems::GetSelection
int retwxControlWithItemsGetSelection0 = mywxControlWithItems->GetSelection();
// Looking at method wxControlWithItems::GetString
int  * wxControlWithItemsGetStringn0;
wxString retwxControlWithItemsGetString0 = mywxControlWithItems->GetString( * wxControlWithItemsGetStringn0);
// Looking at method wxControlWithItems::GetStringSelection
wxString retwxControlWithItemsGetStringSelection0 = mywxControlWithItems->GetStringSelection();
// Looking at method wxControlWithItems::Insert
wxString   * wxControlWithItemsInsertitem0;
int  * wxControlWithItemsInsertpos1;
int retwxControlWithItemsInsert0 = mywxControlWithItems->Insert( * wxControlWithItemsInsertitem0,  * wxControlWithItemsInsertpos1);
wxString   * wxControlWithItemsInsertitem2;
int  * wxControlWithItemsInsertpos3;
void * * wxControlWithItemsInsertclientData4;
int retwxControlWithItemsInsert1 = mywxControlWithItems->Insert( * wxControlWithItemsInsertitem2,  * wxControlWithItemsInsertpos3,  * wxControlWithItemsInsertclientData4);
wxString   * wxControlWithItemsInsertitem5;
int  * wxControlWithItemsInsertpos6;
wxClientData * * wxControlWithItemsInsertclientData7;
int retwxControlWithItemsInsert2 = mywxControlWithItems->Insert( * wxControlWithItemsInsertitem5,  * wxControlWithItemsInsertpos6,  * wxControlWithItemsInsertclientData7);
// Looking at method wxControlWithItems::IsEmpty
bool retwxControlWithItemsIsEmpty0 = mywxControlWithItems->IsEmpty();
// Looking at method wxControlWithItems::Number
// Looking at method wxControlWithItems::Select
int  * wxControlWithItemsSelectn0;
mywxControlWithItems->Select( * wxControlWithItemsSelectn0);
// Looking at method wxControlWithItems::SetClientData
int  * wxControlWithItemsSetClientDatan0;
void * * wxControlWithItemsSetClientDatadata1;
mywxControlWithItems->SetClientData( * wxControlWithItemsSetClientDatan0,  * wxControlWithItemsSetClientDatadata1);
// Looking at method wxControlWithItems::SetClientObject
int  * wxControlWithItemsSetClientObjectn0;
wxClientData * * wxControlWithItemsSetClientObjectdata1;
mywxControlWithItems->SetClientObject( * wxControlWithItemsSetClientObjectn0,  * wxControlWithItemsSetClientObjectdata1);
// Looking at method wxControlWithItems::SetSelection
int  * wxControlWithItemsSetSelectionn0;
mywxControlWithItems->SetSelection( * wxControlWithItemsSetSelectionn0);
// Looking at method wxControlWithItems::SetString
int  * wxControlWithItemsSetStringn0;
wxString   * wxControlWithItemsSetStringstring1;
mywxControlWithItems->SetString( * wxControlWithItemsSetStringn0,  * wxControlWithItemsSetStringstring1);
// Looking at method wxControlWithItems::SetStringSelection
wxString   * wxControlWithItemsSetStringSelectionstring0;
bool retwxControlWithItemsSetStringSelection0 = mywxControlWithItems->SetStringSelection( * wxControlWithItemsSetStringSelectionstring0);

// Looking at class wxCountingOutputStream
wxCountingOutputStream * mywxCountingOutputStream;
// Looking at method wxCountingOutputStream::wxCountingOutputStream
wxCountingOutputStream * newwxCountingOutputStream0 = new wxCountingOutputStream();
// Looking at method wxCountingOutputStream::GetSize
size_t retwxCountingOutputStreamGetSize0 = mywxCountingOutputStream->GetSize();

// Looking at class wxCriticalSection
wxCriticalSection * mywxCriticalSection;
// Looking at method wxCriticalSection::wxCriticalSection
wxCriticalSection * newwxCriticalSection0 = new wxCriticalSection();
// Looking at method wxCriticalSection::Enter
mywxCriticalSection->Enter();
// Looking at method wxCriticalSection::Leave
mywxCriticalSection->Leave();

// Looking at class wxCriticalSectionLocker
wxCriticalSectionLocker * mywxCriticalSectionLocker;
// Looking at method wxCriticalSectionLocker::wxCriticalSectionLocker
wxCriticalSection  * wxCriticalSectionLockerwxCriticalSectionLockercriticalsection0;
wxCriticalSectionLocker * newwxCriticalSectionLocker0 = new wxCriticalSectionLocker( * wxCriticalSectionLockerwxCriticalSectionLockercriticalsection0);

// Looking at class wxCursor
wxCursor * mywxCursor;
// Looking at method wxCursor::wxCursor
wxCursor * newwxCursor0 = new wxCursor();
char  * * wxCursorwxCursorbitsptr0;
int  * wxCursorwxCursorwidth1;
int   * wxCursorwxCursorheight2;
int  * wxCursorwxCursorhotSpotX3;
int  * wxCursorwxCursorhotSpotY4;
char  * * wxCursorwxCursormaskBitsptr5;
wxColour*  * wxCursorwxCursorfg6;
wxColour*  * wxCursorwxCursorbg7;
wxCursor * newwxCursor1 = new wxCursor( * wxCursorwxCursorbitsptr0,  * wxCursorwxCursorwidth1,  * wxCursorwxCursorheight2,  * wxCursorwxCursorhotSpotX3,  * wxCursorwxCursorhotSpotY4,  * wxCursorwxCursormaskBitsptr5,  * wxCursorwxCursorfg6,  * wxCursorwxCursorbg7);
wxString  * wxCursorwxCursorcursorName8;
long  * wxCursorwxCursortype9;
int  * wxCursorwxCursorhotSpotX10;
int  * wxCursorwxCursorhotSpotY11;
wxCursor * newwxCursor2 = new wxCursor( * wxCursorwxCursorcursorName8,  * wxCursorwxCursortype9,  * wxCursorwxCursorhotSpotX10,  * wxCursorwxCursorhotSpotY11);
int  * wxCursorwxCursorcursorId12;
wxCursor * newwxCursor3 = new wxCursor( * wxCursorwxCursorcursorId12);
wxImage  * wxCursorwxCursorimage13;
wxCursor * newwxCursor4 = new wxCursor( * wxCursorwxCursorimage13);
wxCursor  * wxCursorwxCursorcursor14;
wxCursor * newwxCursor5 = new wxCursor( * wxCursorwxCursorcursor14);
// Looking at method wxCursor::Ok
bool retwxCursorOk0 = mywxCursor->Ok();

// Looking at class wxCustomDataObject
wxCustomDataObject * mywxCustomDataObject;
// Looking at method wxCustomDataObject::wxCustomDataObject
wxDataFormat  * wxCustomDataObjectwxCustomDataObjectformat0;
wxCustomDataObject * newwxCustomDataObject0 = new wxCustomDataObject( * wxCustomDataObjectwxCustomDataObjectformat0);
// Looking at method wxCustomDataObject::Alloc
// Looking at method wxCustomDataObject::Free
// Looking at method wxCustomDataObject::GetSize
// Looking at method wxCustomDataObject::GetData
// Looking at method wxCustomDataObject::SetData
// Looking at method wxCustomDataObject::TakeData

// Looking at class wxDCClipper
wxDCClipper * mywxDCClipper;
// Looking at method wxDCClipper::wxDCClipper
wxDC  * wxDCClipperwxDCClipperdc0;
wxCoord  * wxDCClipperwxDCClipperx1;
wxCoord  * wxDCClipperwxDCClippery2;
wxCoord  * wxDCClipperwxDCClipperw3;
wxCoord  * wxDCClipperwxDCClipperh4;
wxDCClipper * newwxDCClipper0 = new wxDCClipper( * wxDCClipperwxDCClipperdc0,  * wxDCClipperwxDCClipperx1,  * wxDCClipperwxDCClippery2,  * wxDCClipperwxDCClipperw3,  * wxDCClipperwxDCClipperh4);
wxDC  * wxDCClipperwxDCClipperdc5;
wxRect  * wxDCClipperwxDCClipperrect6;
wxDCClipper * newwxDCClipper1 = new wxDCClipper( * wxDCClipperwxDCClipperdc5,  * wxDCClipperwxDCClipperrect6);

// Looking at class wxDataFormat
wxDataFormat * mywxDataFormat;
// Looking at method wxDataFormat::wxDataFormat
NativeFormat  * wxDataFormatwxDataFormatformat0;
wxDataFormat * newwxDataFormat0 = new wxDataFormat( * wxDataFormatwxDataFormatformat0);
wxChar * * wxDataFormatwxDataFormatformat1;
wxDataFormat * newwxDataFormat1 = new wxDataFormat( * wxDataFormatwxDataFormatformat1);
// Looking at method wxDataFormat::GetId
wxString retwxDataFormatGetId0 = mywxDataFormat->GetId();
// Looking at method wxDataFormat::GetType
NativeFormat retwxDataFormatGetType0 = mywxDataFormat->GetType();
// Looking at method wxDataFormat::SetId
wxChar * * wxDataFormatSetIdformat0;
mywxDataFormat->SetId( * wxDataFormatSetIdformat0);
// Looking at method wxDataFormat::SetType
NativeFormat  * wxDataFormatSetTypeformat0;
mywxDataFormat->SetType( * wxDataFormatSetTypeformat0);

// Looking at class wxDataInputStream
wxDataInputStream * mywxDataInputStream;
// Looking at method wxDataInputStream::wxDataInputStream
wxInputStream  * wxDataInputStreamwxDataInputStreamstream0;
wxDataInputStream * newwxDataInputStream0 = new wxDataInputStream( * wxDataInputStreamwxDataInputStreamstream0);
#if wxUSE_UNICODE == 1
wxInputStream  * wxDataInputStreamwxDataInputStreamstream1;
wxMBConv  * wxDataInputStreamwxDataInputStreamconv2;
wxDataInputStream * newwxDataInputStream1 = new wxDataInputStream( * wxDataInputStreamwxDataInputStreamstream1,  * wxDataInputStreamwxDataInputStreamconv2);
#endif //wxUSE_UNICODE
// Looking at method wxDataInputStream::BigEndianOrdered
bool  * wxDataInputStreamBigEndianOrderedbe_order0;
mywxDataInputStream->BigEndianOrdered( * wxDataInputStreamBigEndianOrderedbe_order0);
// Looking at method wxDataInputStream::Read8
wxUint8 retwxDataInputStreamRead80 = mywxDataInputStream->Read8();
wxUint8 * * wxDataInputStreamRead8buffer0;
size_t  * wxDataInputStreamRead8size1;
mywxDataInputStream->Read8( * wxDataInputStreamRead8buffer0,  * wxDataInputStreamRead8size1);
// Looking at method wxDataInputStream::Read16
wxUint16 retwxDataInputStreamRead160 = mywxDataInputStream->Read16();
wxUint16 * * wxDataInputStreamRead16buffer0;
size_t  * wxDataInputStreamRead16size1;
mywxDataInputStream->Read16( * wxDataInputStreamRead16buffer0,  * wxDataInputStreamRead16size1);
// Looking at method wxDataInputStream::Read32
wxUint32 retwxDataInputStreamRead320 = mywxDataInputStream->Read32();
wxUint32 * * wxDataInputStreamRead32buffer0;
size_t  * wxDataInputStreamRead32size1;
mywxDataInputStream->Read32( * wxDataInputStreamRead32buffer0,  * wxDataInputStreamRead32size1);
// Looking at method wxDataInputStream::Read64
wxUint64 retwxDataInputStreamRead640 = mywxDataInputStream->Read64();
wxUint64 * * wxDataInputStreamRead64buffer0;
size_t  * wxDataInputStreamRead64size1;
mywxDataInputStream->Read64( * wxDataInputStreamRead64buffer0,  * wxDataInputStreamRead64size1);
// Looking at method wxDataInputStream::ReadDouble
double retwxDataInputStreamReadDouble0 = mywxDataInputStream->ReadDouble();
double * * wxDataInputStreamReadDoublebuffer0;
size_t  * wxDataInputStreamReadDoublesize1;
mywxDataInputStream->ReadDouble( * wxDataInputStreamReadDoublebuffer0,  * wxDataInputStreamReadDoublesize1);
// Looking at method wxDataInputStream::ReadString
wxString retwxDataInputStreamReadString0 = mywxDataInputStream->ReadString();

// Looking at class wxDataObjectComposite
wxDataObjectComposite * mywxDataObjectComposite;
// Looking at method wxDataObjectComposite::wxDataObjectComposite
wxDataObjectComposite * newwxDataObjectComposite0 = new wxDataObjectComposite();
// Looking at method wxDataObjectComposite::Add
wxDataObjectSimple * * wxDataObjectCompositeAdddataObject0;
bool  * wxDataObjectCompositeAddpreferred1;
mywxDataObjectComposite->Add( * wxDataObjectCompositeAdddataObject0,  * wxDataObjectCompositeAddpreferred1);

// Looking at class wxDataObjectSimple
wxDataObjectSimple * mywxDataObjectSimple;
// Looking at method wxDataObjectSimple::wxDataObjectSimple
wxDataFormat  * wxDataObjectSimplewxDataObjectSimpleformat0;
wxDataObjectSimple * newwxDataObjectSimple0 = new wxDataObjectSimple( * wxDataObjectSimplewxDataObjectSimpleformat0);
// Looking at method wxDataObjectSimple::GetFormat
const wxDataFormat retwxDataObjectSimpleGetFormat0 = mywxDataObjectSimple->GetFormat();
// Looking at method wxDataObjectSimple::SetFormat
wxDataFormat  * wxDataObjectSimpleSetFormatformat0;
mywxDataObjectSimple->SetFormat( * wxDataObjectSimpleSetFormatformat0);
// Looking at method wxDataObjectSimple::GetDataSize
// Looking at method wxDataObjectSimple::GetDataHere
// Looking at method wxDataObjectSimple::SetData

// Looking at class wxDataOutputStream
wxDataOutputStream * mywxDataOutputStream;
// Looking at method wxDataOutputStream::wxDataOutputStream
wxOutputStream  * wxDataOutputStreamwxDataOutputStreamstream0;
wxDataOutputStream * newwxDataOutputStream0 = new wxDataOutputStream( * wxDataOutputStreamwxDataOutputStreamstream0);
wxOutputStream  * wxDataOutputStreamwxDataOutputStreamstream1;
wxMBConv  * wxDataOutputStreamwxDataOutputStreamconv2;
wxDataOutputStream * newwxDataOutputStream1 = new wxDataOutputStream( * wxDataOutputStreamwxDataOutputStreamstream1,  * wxDataOutputStreamwxDataOutputStreamconv2);
// Looking at method wxDataOutputStream::BigEndianOrdered
bool  * wxDataOutputStreamBigEndianOrderedbe_order0;
mywxDataOutputStream->BigEndianOrdered( * wxDataOutputStreamBigEndianOrderedbe_order0);
// Looking at method wxDataOutputStream::Write8
wxUint8  * wxDataOutputStreamWrite8i80;
mywxDataOutputStream->Write8( * wxDataOutputStreamWrite8i80);
wxUint8 * * wxDataOutputStreamWrite8buffer1;
size_t  * wxDataOutputStreamWrite8size2;
mywxDataOutputStream->Write8( * wxDataOutputStreamWrite8buffer1,  * wxDataOutputStreamWrite8size2);
// Looking at method wxDataOutputStream::Write16
wxUint16  * wxDataOutputStreamWrite16i160;
mywxDataOutputStream->Write16( * wxDataOutputStreamWrite16i160);
wxUint16 * * wxDataOutputStreamWrite16buffer1;
size_t  * wxDataOutputStreamWrite16size2;
mywxDataOutputStream->Write16( * wxDataOutputStreamWrite16buffer1,  * wxDataOutputStreamWrite16size2);
// Looking at method wxDataOutputStream::Write32
wxUint32  * wxDataOutputStreamWrite32i320;
mywxDataOutputStream->Write32( * wxDataOutputStreamWrite32i320);
wxUint32 * * wxDataOutputStreamWrite32buffer1;
size_t  * wxDataOutputStreamWrite32size2;
mywxDataOutputStream->Write32( * wxDataOutputStreamWrite32buffer1,  * wxDataOutputStreamWrite32size2);
// Looking at method wxDataOutputStream::Write64
wxUint64  * wxDataOutputStreamWrite64i640;
mywxDataOutputStream->Write64( * wxDataOutputStreamWrite64i640);
wxUint64 * * wxDataOutputStreamWrite64buffer1;
size_t  * wxDataOutputStreamWrite64size2;
mywxDataOutputStream->Write64( * wxDataOutputStreamWrite64buffer1,  * wxDataOutputStreamWrite64size2);
// Looking at method wxDataOutputStream::WriteDouble
double  * wxDataOutputStreamWriteDoublef0;
mywxDataOutputStream->WriteDouble( * wxDataOutputStreamWriteDoublef0);
double * * wxDataOutputStreamWriteDoublebuffer1;
size_t  * wxDataOutputStreamWriteDoublesize2;
mywxDataOutputStream->WriteDouble( * wxDataOutputStreamWriteDoublebuffer1,  * wxDataOutputStreamWriteDoublesize2);
// Looking at method wxDataOutputStream::WriteString
wxString * wxDataOutputStreamWriteStringstring0;
mywxDataOutputStream->WriteString( * wxDataOutputStreamWriteStringstring0);

// Looking at class wxDateEvent
wxDateEvent * mywxDateEvent;
// Looking at method wxDateEvent::GetDate
const wxDateTime retwxDateEventGetDate0 = mywxDateEvent->GetDate();
// Looking at method wxDateEvent::SetDate
wxDateTime  * wxDateEventSetDatedate0;
mywxDateEvent->SetDate( * wxDateEventSetDatedate0);
#if wxUSE_DATEPICKCTRL == 1

// Looking at class wxDatePickerCtrl
wxDatePickerCtrl * mywxDatePickerCtrl;
// Looking at method wxDatePickerCtrl::wxDatePickerCtrl
wxWindow * * wxDatePickerCtrlwxDatePickerCtrlparent0;
wxWindowID  * wxDatePickerCtrlwxDatePickerCtrlid1;
wxDateTime  * wxDatePickerCtrlwxDatePickerCtrldt2;
wxPoint  * wxDatePickerCtrlwxDatePickerCtrlpos3;
wxSize  * wxDatePickerCtrlwxDatePickerCtrlsize4;
long  * wxDatePickerCtrlwxDatePickerCtrlstyle5;
wxValidator  * wxDatePickerCtrlwxDatePickerCtrlvalidator6;
wxString  * wxDatePickerCtrlwxDatePickerCtrlname7;
wxDatePickerCtrl * newwxDatePickerCtrl0 = new wxDatePickerCtrl( * wxDatePickerCtrlwxDatePickerCtrlparent0,  * wxDatePickerCtrlwxDatePickerCtrlid1,  * wxDatePickerCtrlwxDatePickerCtrldt2,  * wxDatePickerCtrlwxDatePickerCtrlpos3,  * wxDatePickerCtrlwxDatePickerCtrlsize4,  * wxDatePickerCtrlwxDatePickerCtrlstyle5,  * wxDatePickerCtrlwxDatePickerCtrlvalidator6,  * wxDatePickerCtrlwxDatePickerCtrlname7);
// Looking at method wxDatePickerCtrl::Create
wxWindow * * wxDatePickerCtrlCreateparent0;
wxWindowID  * wxDatePickerCtrlCreateid1;
wxDateTime  * wxDatePickerCtrlCreatedt2;
wxPoint  * wxDatePickerCtrlCreatepos3;
wxSize  * wxDatePickerCtrlCreatesize4;
long  * wxDatePickerCtrlCreatestyle5;
wxValidator  * wxDatePickerCtrlCreatevalidator6;
wxString  * wxDatePickerCtrlCreatename7;
bool retwxDatePickerCtrlCreate0 = mywxDatePickerCtrl->Create( * wxDatePickerCtrlCreateparent0,  * wxDatePickerCtrlCreateid1,  * wxDatePickerCtrlCreatedt2,  * wxDatePickerCtrlCreatepos3,  * wxDatePickerCtrlCreatesize4,  * wxDatePickerCtrlCreatestyle5,  * wxDatePickerCtrlCreatevalidator6,  * wxDatePickerCtrlCreatename7);
// Looking at method wxDatePickerCtrl::GetRange
wxDateTime * * wxDatePickerCtrlGetRangedt10;
wxDateTime * * wxDatePickerCtrlGetRangedt21;
bool retwxDatePickerCtrlGetRange0 = mywxDatePickerCtrl->GetRange( * wxDatePickerCtrlGetRangedt10,  * wxDatePickerCtrlGetRangedt21);
// Looking at method wxDatePickerCtrl::GetValue
wxDateTime retwxDatePickerCtrlGetValue0 = mywxDatePickerCtrl->GetValue();
// Looking at method wxDatePickerCtrl::SetRange
wxDateTime  * wxDatePickerCtrlSetRangedt10;
wxDateTime  * wxDatePickerCtrlSetRangedt21;
mywxDatePickerCtrl->SetRange( * wxDatePickerCtrlSetRangedt10,  * wxDatePickerCtrlSetRangedt21);
// Looking at method wxDatePickerCtrl::SetValue
wxDateTime  * wxDatePickerCtrlSetValuedt0;
mywxDatePickerCtrl->SetValue( * wxDatePickerCtrlSetValuedt0);
#endif //wxUSE_DATEPICKCTRL

// Looking at class wxDateSpan
wxDateSpan * mywxDateSpan;
// Looking at method wxDateSpan::wxDateSpan
int  * wxDateSpanwxDateSpanyears0;
int  * wxDateSpanwxDateSpanmonths1;
int  * wxDateSpanwxDateSpanweeks2;
int  * wxDateSpanwxDateSpandays3;
wxDateSpan * newwxDateSpan0 = new wxDateSpan( * wxDateSpanwxDateSpanyears0,  * wxDateSpanwxDateSpanmonths1,  * wxDateSpanwxDateSpanweeks2,  * wxDateSpanwxDateSpandays3);
// Looking at method wxDateSpan::Add
wxDateSpan  * wxDateSpanAddother0;
wxDateSpan retwxDateSpanAdd0 = mywxDateSpan->Add( * wxDateSpanAddother0);
wxDateSpan  * wxDateSpanAddother1;
wxDateSpan retwxDateSpanAdd1 = mywxDateSpan->Add( * wxDateSpanAddother1);
// Looking at method wxDateSpan::Day
static wxDateSpan retwxDateSpanDay0 = mywxDateSpan->Day();
// Looking at method wxDateSpan::Days
int  * wxDateSpanDaysdays0;
static wxDateSpan retwxDateSpanDays0 = mywxDateSpan->Days( * wxDateSpanDaysdays0);
// Looking at method wxDateSpan::GetDays
int retwxDateSpanGetDays0 = mywxDateSpan->GetDays();
// Looking at method wxDateSpan::GetMonths
int retwxDateSpanGetMonths0 = mywxDateSpan->GetMonths();
// Looking at method wxDateSpan::GetTotalDays
int retwxDateSpanGetTotalDays0 = mywxDateSpan->GetTotalDays();
// Looking at method wxDateSpan::GetWeeks
int retwxDateSpanGetWeeks0 = mywxDateSpan->GetWeeks();
// Looking at method wxDateSpan::GetYears
int retwxDateSpanGetYears0 = mywxDateSpan->GetYears();
// Looking at method wxDateSpan::Month
static wxDateSpan retwxDateSpanMonth0 = mywxDateSpan->Month();
// Looking at method wxDateSpan::Months
int  * wxDateSpanMonthsmon0;
static wxDateSpan retwxDateSpanMonths0 = mywxDateSpan->Months( * wxDateSpanMonthsmon0);
// Looking at method wxDateSpan::Multiply
int  * wxDateSpanMultiplyfactor0;
wxDateSpan retwxDateSpanMultiply0 = mywxDateSpan->Multiply( * wxDateSpanMultiplyfactor0);
int  * wxDateSpanMultiplyfactor1;
wxDateSpan retwxDateSpanMultiply1 = mywxDateSpan->Multiply( * wxDateSpanMultiplyfactor1);
// Looking at method wxDateSpan::Negate
wxDateSpan retwxDateSpanNegate0 = mywxDateSpan->Negate();
// Looking at method wxDateSpan::Neg
wxDateSpan retwxDateSpanNeg0 = mywxDateSpan->Neg();
// Looking at method wxDateSpan::SetDays
int  * wxDateSpanSetDaysn0;
wxDateSpan retwxDateSpanSetDays0 = mywxDateSpan->SetDays( * wxDateSpanSetDaysn0);
// Looking at method wxDateSpan::SetYears
int  * wxDateSpanSetYearsn0;
wxDateSpan retwxDateSpanSetYears0 = mywxDateSpan->SetYears( * wxDateSpanSetYearsn0);
// Looking at method wxDateSpan::SetMonths
int  * wxDateSpanSetMonthsn0;
wxDateSpan retwxDateSpanSetMonths0 = mywxDateSpan->SetMonths( * wxDateSpanSetMonthsn0);
// Looking at method wxDateSpan::SetWeeks
int  * wxDateSpanSetWeeksn0;
wxDateSpan retwxDateSpanSetWeeks0 = mywxDateSpan->SetWeeks( * wxDateSpanSetWeeksn0);
// Looking at method wxDateSpan::Subtract
wxDateSpan  * wxDateSpanSubtractother0;
wxDateSpan retwxDateSpanSubtract0 = mywxDateSpan->Subtract( * wxDateSpanSubtractother0);
wxDateSpan  * wxDateSpanSubtractother1;
wxDateSpan retwxDateSpanSubtract1 = mywxDateSpan->Subtract( * wxDateSpanSubtractother1);
// Looking at method wxDateSpan::Week
static wxDateSpan retwxDateSpanWeek0 = mywxDateSpan->Week();
// Looking at method wxDateSpan::Weeks
int  * wxDateSpanWeeksweeks0;
static wxDateSpan retwxDateSpanWeeks0 = mywxDateSpan->Weeks( * wxDateSpanWeeksweeks0);
// Looking at method wxDateSpan::Year
static wxDateSpan retwxDateSpanYear0 = mywxDateSpan->Year();
// Looking at method wxDateSpan::Years
int  * wxDateSpanYearsyears0;
static wxDateSpan retwxDateSpanYears0 = mywxDateSpan->Years( * wxDateSpanYearsyears0);

// Looking at class wxDateTimeHolidayAuthority
wxDateTimeHolidayAuthority * mywxDateTimeHolidayAuthority;

// Looking at class wxDateTimeWorkDays
wxDateTimeWorkDays * mywxDateTimeWorkDays;
#if wxUSE_ODBC == 1

// Looking at class wxDbColDataPtr
wxDbColDataPtr * mywxDbColDataPtr;
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbColDef
wxDbColDef * mywxDbColDef;
// Looking at method wxDbColDef::Initialize
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbColFor
wxDbColFor * mywxDbColFor;
// Looking at method wxDbColFor::Format
int  * wxDbColForFormatNation0;
int  * wxDbColForFormatdbDataType1;
SWORD  * wxDbColForFormatsqlDataType2;
short  * wxDbColForFormatcolumnSize3;
short  * wxDbColForFormatdecimalDigits4;
int  retwxDbColForFormat0 = mywxDbColFor->Format( * wxDbColForFormatNation0,  * wxDbColForFormatdbDataType1,  * wxDbColForFormatsqlDataType2,  * wxDbColForFormatcolumnSize3,  * wxDbColForFormatdecimalDigits4);
// Looking at method wxDbColFor::Initialize
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbColInf
wxDbColInf * mywxDbColInf;
// Looking at method wxDbColInf::Initialize
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbGridColInfo
wxDbGridColInfo * mywxDbGridColInfo;
// Looking at method wxDbGridColInfo::wxDbGridColInfo
int  * wxDbGridColInfowxDbGridColInfocolNumber0;
wxString  * wxDbGridColInfowxDbGridColInfotype1;
wxString  * wxDbGridColInfowxDbGridColInfotitle2;
wxDbGridColInfo * * wxDbGridColInfowxDbGridColInfonext3;
wxDbGridColInfo * newwxDbGridColInfo0 = new wxDbGridColInfo( * wxDbGridColInfowxDbGridColInfocolNumber0,  * wxDbGridColInfowxDbGridColInfotype1,  * wxDbGridColInfowxDbGridColInfotitle2,  * wxDbGridColInfowxDbGridColInfonext3);
// Looking at method wxDbGridColInfo::AddColInfo
int  * wxDbGridColInfoAddColInfocolNumber0;
wxString  * wxDbGridColInfoAddColInfotype1;
wxString  * wxDbGridColInfoAddColInfotitle2;
mywxDbGridColInfo->AddColInfo( * wxDbGridColInfoAddColInfocolNumber0,  * wxDbGridColInfoAddColInfotype1,  * wxDbGridColInfoAddColInfotitle2);
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbIdxDef
wxDbIdxDef * mywxDbIdxDef;
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbInf
wxDbInf * mywxDbInf;
// Looking at method wxDbInf::Initialize
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbTable
wxDbTable * mywxDbTable;
// Looking at method wxDbTable::wxDbTable
wxDb * * wxDbTablewxDbTablepwxDb0;
wxString  * wxDbTablewxDbTabletblName1;
UWORD  * wxDbTablewxDbTablenumColumns2;
wxString  * wxDbTablewxDbTableqryTblName3;
bool  * wxDbTablewxDbTableqryOnly4;
wxString  * wxDbTablewxDbTabletblPath5;
wxDbTable * newwxDbTable0 = new wxDbTable( * wxDbTablewxDbTablepwxDb0,  * wxDbTablewxDbTabletblName1,  * wxDbTablewxDbTablenumColumns2,  * wxDbTablewxDbTableqryTblName3,  * wxDbTablewxDbTableqryOnly4,  * wxDbTablewxDbTabletblPath5);
// Looking at method wxDbTable::wxDbTable
// Looking at method wxDbTable::BuildDeleteStmt
wxString  * wxDbTableBuildDeleteStmtpSqlStmt0;
int  * wxDbTableBuildDeleteStmttypeOfDel1;
wxString  * wxDbTableBuildDeleteStmtpWhereClause2;
mywxDbTable->BuildDeleteStmt( * wxDbTableBuildDeleteStmtpSqlStmt0,  * wxDbTableBuildDeleteStmttypeOfDel1,  * wxDbTableBuildDeleteStmtpWhereClause2);
// Looking at method wxDbTable::BuildSelectStmt
wxString  * wxDbTableBuildSelectStmtpSqlStmt0;
int  * wxDbTableBuildSelectStmttypeOfSelect1;
bool  * wxDbTableBuildSelectStmtdistinct2;
mywxDbTable->BuildSelectStmt( * wxDbTableBuildSelectStmtpSqlStmt0,  * wxDbTableBuildSelectStmttypeOfSelect1,  * wxDbTableBuildSelectStmtdistinct2);
// Looking at method wxDbTable::BuildUpdateStmt
wxString  * wxDbTableBuildUpdateStmtpSqlStmt0;
int  * wxDbTableBuildUpdateStmttypeOfUpd1;
wxString  * wxDbTableBuildUpdateStmtpWhereClause2;
mywxDbTable->BuildUpdateStmt( * wxDbTableBuildUpdateStmtpSqlStmt0,  * wxDbTableBuildUpdateStmttypeOfUpd1,  * wxDbTableBuildUpdateStmtpWhereClause2);
// Looking at method wxDbTable::BuildWhereClause
wxString  * wxDbTableBuildWhereClausepWhereClause0;
int  * wxDbTableBuildWhereClausetypeOfWhere1;
wxString  * wxDbTableBuildWhereClausequalTableName2;
bool  * wxDbTableBuildWhereClauseuseLikeComparison3;
mywxDbTable->BuildWhereClause( * wxDbTableBuildWhereClausepWhereClause0,  * wxDbTableBuildWhereClausetypeOfWhere1,  * wxDbTableBuildWhereClausequalTableName2,  * wxDbTableBuildWhereClauseuseLikeComparison3);
// Looking at method wxDbTable::CanSelectForUpdate
bool retwxDbTableCanSelectForUpdate0 = mywxDbTable->CanSelectForUpdate();
// Looking at method wxDbTable::CanUpdateByROWID
bool retwxDbTableCanUpdateByROWID0 = mywxDbTable->CanUpdateByROWID();
// Looking at method wxDbTable::ClearMemberVar
UWORD  * wxDbTableClearMemberVarcolNumber0;
bool  * wxDbTableClearMemberVarsetToNull1;
mywxDbTable->ClearMemberVar( * wxDbTableClearMemberVarcolNumber0,  * wxDbTableClearMemberVarsetToNull1);
// Looking at method wxDbTable::ClearMemberVars
bool  * wxDbTableClearMemberVarssetToNull0;
mywxDbTable->ClearMemberVars( * wxDbTableClearMemberVarssetToNull0);
// Looking at method wxDbTable::CloseCursor
HSTMT * wxDbTableCloseCursorcursor0;
bool retwxDbTableCloseCursor0 = mywxDbTable->CloseCursor( * wxDbTableCloseCursorcursor0);
// Looking at method wxDbTable::Count
wxString  * wxDbTableCountargs0;
ULONG  retwxDbTableCount0 = mywxDbTable->Count( * wxDbTableCountargs0);
// Looking at method wxDbTable::CreateIndex
wxString  * wxDbTableCreateIndexIndexName0;
bool  * wxDbTableCreateIndexunique1;
UWORD  * wxDbTableCreateIndexnumIndexColumns2;
wxDbIdxDef * * wxDbTableCreateIndexpIndexDefs3;
bool  * wxDbTableCreateIndexattemptDrop4;
bool retwxDbTableCreateIndex0 = mywxDbTable->CreateIndex( * wxDbTableCreateIndexIndexName0,  * wxDbTableCreateIndexunique1,  * wxDbTableCreateIndexnumIndexColumns2,  * wxDbTableCreateIndexpIndexDefs3,  * wxDbTableCreateIndexattemptDrop4);
// Looking at method wxDbTable::CreateTable
bool  * wxDbTableCreateTableattemptDrop0;
bool retwxDbTableCreateTable0 = mywxDbTable->CreateTable( * wxDbTableCreateTableattemptDrop0);
// Looking at method wxDbTable::DB_STATUS
bool retwxDbTableDB_STATUS0 = mywxDbTable->DB_STATUS();
// Looking at method wxDbTable::Delete
bool retwxDbTableDelete0 = mywxDbTable->Delete();
// Looking at method wxDbTable::DeleteCursor
HSTMT * * wxDbTableDeleteCursorhstmtDel0;
bool retwxDbTableDeleteCursor0 = mywxDbTable->DeleteCursor( * wxDbTableDeleteCursorhstmtDel0);
// Looking at method wxDbTable::DeleteMatching
bool retwxDbTableDeleteMatching0 = mywxDbTable->DeleteMatching();
// Looking at method wxDbTable::DeleteWhere
wxString  * wxDbTableDeleteWherepWhereClause0;
bool retwxDbTableDeleteWhere0 = mywxDbTable->DeleteWhere( * wxDbTableDeleteWherepWhereClause0);
// Looking at method wxDbTable::DropIndex
wxString  * wxDbTableDropIndexIndexName0;
bool retwxDbTableDropIndex0 = mywxDbTable->DropIndex( * wxDbTableDropIndexIndexName0);
// Looking at method wxDbTable::DropTable
bool retwxDbTableDropTable0 = mywxDbTable->DropTable();
// Looking at method wxDbTable::From
const wxString  retwxDbTableFrom0 = mywxDbTable->From();
wxString  * wxDbTableFromFrom0;
mywxDbTable->From( * wxDbTableFromFrom0);
// Looking at method wxDbTable::GetColDefs
wxDbColDef * retwxDbTableGetColDefs0 = mywxDbTable->GetColDefs();
// Looking at method wxDbTable::GetCursor
HSTMT retwxDbTableGetCursor0 = mywxDbTable->GetCursor();
// Looking at method wxDbTable::GetDb
wxDb * retwxDbTableGetDb0 = mywxDbTable->GetDb();
// Looking at method wxDbTable::GetFirst
bool retwxDbTableGetFirst0 = mywxDbTable->GetFirst();
// Looking at method wxDbTable::GetFromClause
const wxString  retwxDbTableGetFromClause0 = mywxDbTable->GetFromClause();
// Looking at method wxDbTable::GetLast
bool retwxDbTableGetLast0 = mywxDbTable->GetLast();
// Looking at method wxDbTable::GetNewCursor
bool  * wxDbTableGetNewCursorsetCursor0;
bool  * wxDbTableGetNewCursorbindColumns1;
HSTMT * retwxDbTableGetNewCursor0 = mywxDbTable->GetNewCursor( * wxDbTableGetNewCursorsetCursor0,  * wxDbTableGetNewCursorbindColumns1);
// Looking at method wxDbTable::GetNext
bool retwxDbTableGetNext0 = mywxDbTable->GetNext();
// Looking at method wxDbTable::GetNumberOfColumns
UWORD  retwxDbTableGetNumberOfColumns0 = mywxDbTable->GetNumberOfColumns();
// Looking at method wxDbTable::GetOrderByClause
const wxString  retwxDbTableGetOrderByClause0 = mywxDbTable->GetOrderByClause();
// Looking at method wxDbTable::GetPrev
bool retwxDbTableGetPrev0 = mywxDbTable->GetPrev();
// Looking at method wxDbTable::GetQueryTableName
const wxString  retwxDbTableGetQueryTableName0 = mywxDbTable->GetQueryTableName();
// Looking at method wxDbTable::GetRowNum
UWORD retwxDbTableGetRowNum0 = mywxDbTable->GetRowNum();
// Looking at method wxDbTable::GetTableName
const wxString  retwxDbTableGetTableName0 = mywxDbTable->GetTableName();
// Looking at method wxDbTable::GetTablePath
const wxString  retwxDbTableGetTablePath0 = mywxDbTable->GetTablePath();
// Looking at method wxDbTable::GetWhereClause
const wxString  retwxDbTableGetWhereClause0 = mywxDbTable->GetWhereClause();
// Looking at method wxDbTable::Insert
int  retwxDbTableInsert0 = mywxDbTable->Insert();
// Looking at method wxDbTable::IsColNull
UWORD  * wxDbTableIsColNullcolNumber0;
bool  retwxDbTableIsColNull0 = mywxDbTable->IsColNull( * wxDbTableIsColNullcolNumber0);
// Looking at method wxDbTable::IsCursorClosedOnCommit
bool  retwxDbTableIsCursorClosedOnCommit0 = mywxDbTable->IsCursorClosedOnCommit();
// Looking at method wxDbTable::IsQueryOnly
bool  retwxDbTableIsQueryOnly0 = mywxDbTable->IsQueryOnly();
// Looking at method wxDbTable::Open
bool  * wxDbTableOpencheckPrivileges0;
bool  * wxDbTableOpencheckTableExists1;
bool  retwxDbTableOpen0 = mywxDbTable->Open( * wxDbTableOpencheckPrivileges0,  * wxDbTableOpencheckTableExists1);
// Looking at method wxDbTable::OrderBy
const wxString  retwxDbTableOrderBy0 = mywxDbTable->OrderBy();
wxString  * wxDbTableOrderByOrderBy0;
mywxDbTable->OrderBy( * wxDbTableOrderByOrderBy0);
// Looking at method wxDbTable::Query
// Looking at method wxDbTable::QueryBySqlStmt
wxString  * wxDbTableQueryBySqlStmtpSqlStmt0;
bool retwxDbTableQueryBySqlStmt0 = mywxDbTable->QueryBySqlStmt( * wxDbTableQueryBySqlStmtpSqlStmt0);
// Looking at method wxDbTable::QueryMatching
// Looking at method wxDbTable::QueryOnKeyFields
bool  * wxDbTableQueryOnKeyFieldsforUpdate0;
bool  * wxDbTableQueryOnKeyFieldsdistinct1;
bool  retwxDbTableQueryOnKeyFields0 = mywxDbTable->QueryOnKeyFields( * wxDbTableQueryOnKeyFieldsforUpdate0,  * wxDbTableQueryOnKeyFieldsdistinct1);
// Looking at method wxDbTable::Refresh
bool retwxDbTableRefresh0 = mywxDbTable->Refresh();
// Looking at method wxDbTable::SetColDefs
UWORD  * wxDbTableSetColDefsindex0;
wxString  * wxDbTableSetColDefsfieldName1;
int  * wxDbTableSetColDefsdataType2;
void * * wxDbTableSetColDefspData3;
SWORD  * wxDbTableSetColDefscType4;
int  * wxDbTableSetColDefssize5;
bool  * wxDbTableSetColDefskeyField6;
bool  * wxDbTableSetColDefsupdateable7;
bool  * wxDbTableSetColDefsinsertAllowed8;
bool  * wxDbTableSetColDefsderivedColumn9;
bool retwxDbTableSetColDefs0 = mywxDbTable->SetColDefs( * wxDbTableSetColDefsindex0,  * wxDbTableSetColDefsfieldName1,  * wxDbTableSetColDefsdataType2,  * wxDbTableSetColDefspData3,  * wxDbTableSetColDefscType4,  * wxDbTableSetColDefssize5,  * wxDbTableSetColDefskeyField6,  * wxDbTableSetColDefsupdateable7,  * wxDbTableSetColDefsinsertAllowed8,  * wxDbTableSetColDefsderivedColumn9);
wxDbColInf * * wxDbTableSetColDefscolInfs10;
UWORD  * wxDbTableSetColDefsnumCols11;
wxDbColDataPtr * retwxDbTableSetColDefs1 = mywxDbTable->SetColDefs( * wxDbTableSetColDefscolInfs10,  * wxDbTableSetColDefsnumCols11);
// Looking at method wxDbTable::SetCursor
HSTMT * * wxDbTableSetCursorhstmtActivate0;
mywxDbTable->SetCursor( * wxDbTableSetCursorhstmtActivate0);
// Looking at method wxDbTable::SetFromClause
wxString  * wxDbTableSetFromClauseFrom0;
mywxDbTable->SetFromClause( * wxDbTableSetFromClauseFrom0);
// Looking at method wxDbTable::SetColNull
UWORD  * wxDbTableSetColNullcolNumber0;
bool  * wxDbTableSetColNullset1;
bool retwxDbTableSetColNull0 = mywxDbTable->SetColNull( * wxDbTableSetColNullcolNumber0,  * wxDbTableSetColNullset1);
wxString  * wxDbTableSetColNullcolName2;
bool  * wxDbTableSetColNullset3;
bool retwxDbTableSetColNull1 = mywxDbTable->SetColNull( * wxDbTableSetColNullcolName2,  * wxDbTableSetColNullset3);
// Looking at method wxDbTable::SetOrderByClause
wxString  * wxDbTableSetOrderByClauseOrderBy0;
mywxDbTable->SetOrderByClause( * wxDbTableSetOrderByClauseOrderBy0);
// Looking at method wxDbTable::SetQueryTimeout
UDWORD  * wxDbTableSetQueryTimeoutnSeconds0;
bool retwxDbTableSetQueryTimeout0 = mywxDbTable->SetQueryTimeout( * wxDbTableSetQueryTimeoutnSeconds0);
// Looking at method wxDbTable::SetWhereClause
wxString  * wxDbTableSetWhereClauseWhere0;
mywxDbTable->SetWhereClause( * wxDbTableSetWhereClauseWhere0);
// Looking at method wxDbTable::Update
bool  retwxDbTableUpdate0 = mywxDbTable->Update();
wxString  * wxDbTableUpdatepSqlStmt0;
bool  retwxDbTableUpdate1 = mywxDbTable->Update( * wxDbTableUpdatepSqlStmt0);
// Looking at method wxDbTable::UpdateWhere
wxString  * wxDbTableUpdateWherepWhereClause0;
bool retwxDbTableUpdateWhere0 = mywxDbTable->UpdateWhere( * wxDbTableUpdateWherepWhereClause0);
// Looking at method wxDbTable::Where
const wxString  retwxDbTableWhere0 = mywxDbTable->Where();
wxString  * wxDbTableWhereWhere0;
mywxDbTable->Where( * wxDbTableWhereWhere0);
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1

// Looking at class wxDbTableInf
wxDbTableInf * mywxDbTableInf;
// Looking at method wxDbTableInf::Initialize
#endif //wxUSE_ODBC
#if __WXDEBUG__ == 1

// Looking at class wxDebugContext
wxDebugContext * mywxDebugContext;
// Looking at method wxDebugContext::Check
int retwxDebugContextCheck0 = mywxDebugContext->Check();
// Looking at method wxDebugContext::Dump
bool retwxDebugContextDump0 = mywxDebugContext->Dump();
// Looking at method wxDebugContext::GetCheckPrevious
bool retwxDebugContextGetCheckPrevious0 = mywxDebugContext->GetCheckPrevious();
// Looking at method wxDebugContext::GetDebugMode
bool retwxDebugContextGetDebugMode0 = mywxDebugContext->GetDebugMode();
// Looking at method wxDebugContext::GetLevel
int retwxDebugContextGetLevel0 = mywxDebugContext->GetLevel();
// Looking at method wxDebugContext::GetStream
ostream retwxDebugContextGetStream0 = mywxDebugContext->GetStream();
// Looking at method wxDebugContext::GetStreamBuf
streambuf* retwxDebugContextGetStreamBuf0 = mywxDebugContext->GetStreamBuf();
// Looking at method wxDebugContext::HasStream
bool retwxDebugContextHasStream0 = mywxDebugContext->HasStream();
// Looking at method wxDebugContext::PrintClasses
bool retwxDebugContextPrintClasses0 = mywxDebugContext->PrintClasses();
// Looking at method wxDebugContext::PrintStatistics
bool  * wxDebugContextPrintStatisticsdetailed0;
bool retwxDebugContextPrintStatistics0 = mywxDebugContext->PrintStatistics( * wxDebugContextPrintStatisticsdetailed0);
// Looking at method wxDebugContext::SetCheckpoint
bool  * wxDebugContextSetCheckpointall0;
mywxDebugContext->SetCheckpoint( * wxDebugContextSetCheckpointall0);
// Looking at method wxDebugContext::SetCheckPrevious
bool  * wxDebugContextSetCheckPreviouscheck0;
mywxDebugContext->SetCheckPrevious( * wxDebugContextSetCheckPreviouscheck0);
// Looking at method wxDebugContext::SetDebugMode
bool  * wxDebugContextSetDebugModedebug0;
mywxDebugContext->SetDebugMode( * wxDebugContextSetDebugModedebug0);
// Looking at method wxDebugContext::SetFile
wxString  * wxDebugContextSetFilefilename0;
bool retwxDebugContextSetFile0 = mywxDebugContext->SetFile( * wxDebugContextSetFilefilename0);
// Looking at method wxDebugContext::SetLevel
int  * wxDebugContextSetLevellevel0;
mywxDebugContext->SetLevel( * wxDebugContextSetLevellevel0);
// Looking at method wxDebugContext::SetStandardError
bool retwxDebugContextSetStandardError0 = mywxDebugContext->SetStandardError();
// Looking at method wxDebugContext::SetStream
ostream*  * wxDebugContextSetStreamstream0;
streambuf*  * wxDebugContextSetStreamstreamBuf1;
mywxDebugContext->SetStream( * wxDebugContextSetStreamstream0,  * wxDebugContextSetStreamstreamBuf1);
#endif //__WXDEBUG__

// Looking at class wxDialUpEvent
wxDialUpEvent * mywxDialUpEvent;
// Looking at method wxDialUpEvent::wxDialUpEvent
bool  * wxDialUpEventwxDialUpEventisConnected0;
bool  * wxDialUpEventwxDialUpEventisOwnEvent1;
wxDialUpEvent * newwxDialUpEvent0 = new wxDialUpEvent( * wxDialUpEventwxDialUpEventisConnected0,  * wxDialUpEventwxDialUpEventisOwnEvent1);
// Looking at method wxDialUpEvent::IsConnectedEvent
bool retwxDialUpEventIsConnectedEvent0 = mywxDialUpEvent->IsConnectedEvent();
// Looking at method wxDialUpEvent::IsOwnEvent
bool retwxDialUpEventIsOwnEvent0 = mywxDialUpEvent->IsOwnEvent();

// Looking at class wxDialUpManager
wxDialUpManager * mywxDialUpManager;
// Looking at method wxDialUpManager::Create
wxDialUpManager* retwxDialUpManagerCreate0 = mywxDialUpManager->Create();
// Looking at method wxDialUpManager::IsOk
bool retwxDialUpManagerIsOk0 = mywxDialUpManager->IsOk();
// Looking at method wxDialUpManager::GetISPNames
wxArrayString  * wxDialUpManagerGetISPNamesnames0;
size_t retwxDialUpManagerGetISPNames0 = mywxDialUpManager->GetISPNames( * wxDialUpManagerGetISPNamesnames0);
// Looking at method wxDialUpManager::Dial
wxString  * wxDialUpManagerDialnameOfISP0;
wxString  * wxDialUpManagerDialusername1;
wxString  * wxDialUpManagerDialpassword2;
bool  * wxDialUpManagerDialasync3;
bool retwxDialUpManagerDial0 = mywxDialUpManager->Dial( * wxDialUpManagerDialnameOfISP0,  * wxDialUpManagerDialusername1,  * wxDialUpManagerDialpassword2,  * wxDialUpManagerDialasync3);
// Looking at method wxDialUpManager::IsDialing
bool retwxDialUpManagerIsDialing0 = mywxDialUpManager->IsDialing();
// Looking at method wxDialUpManager::CancelDialing
bool retwxDialUpManagerCancelDialing0 = mywxDialUpManager->CancelDialing();
// Looking at method wxDialUpManager::HangUp
bool retwxDialUpManagerHangUp0 = mywxDialUpManager->HangUp();
// Looking at method wxDialUpManager::IsAlwaysOnline
bool retwxDialUpManagerIsAlwaysOnline0 = mywxDialUpManager->IsAlwaysOnline();
// Looking at method wxDialUpManager::IsOnline
bool retwxDialUpManagerIsOnline0 = mywxDialUpManager->IsOnline();
// Looking at method wxDialUpManager::SetOnlineStatus
bool  * wxDialUpManagerSetOnlineStatusisOnline0;
mywxDialUpManager->SetOnlineStatus( * wxDialUpManagerSetOnlineStatusisOnline0);
// Looking at method wxDialUpManager::EnableAutoCheckOnlineStatus
size_t  * wxDialUpManagerEnableAutoCheckOnlineStatusnSeconds0;
bool retwxDialUpManagerEnableAutoCheckOnlineStatus0 = mywxDialUpManager->EnableAutoCheckOnlineStatus( * wxDialUpManagerEnableAutoCheckOnlineStatusnSeconds0);
// Looking at method wxDialUpManager::DisableAutoCheckOnlineStatus
mywxDialUpManager->DisableAutoCheckOnlineStatus();
// Looking at method wxDialUpManager::SetWellKnownHost
wxString  * wxDialUpManagerSetWellKnownHosthostname0;
int  * wxDialUpManagerSetWellKnownHostportno1;
mywxDialUpManager->SetWellKnownHost( * wxDialUpManagerSetWellKnownHosthostname0,  * wxDialUpManagerSetWellKnownHostportno1);
// Looking at method wxDialUpManager::SetConnectCommand
wxString  * wxDialUpManagerSetConnectCommandcommandDial0;
wxString  * wxDialUpManagerSetConnectCommandcommandHangup1;
mywxDialUpManager->SetConnectCommand( * wxDialUpManagerSetConnectCommandcommandDial0,  * wxDialUpManagerSetConnectCommandcommandHangup1);

// Looking at class wxDialog
wxDialog * mywxDialog;
// Looking at method wxDialog::wxDialog
wxDialog * newwxDialog0 = new wxDialog();
wxWindow*  * wxDialogwxDialogparent0;
wxWindowID  * wxDialogwxDialogid1;
wxString  * wxDialogwxDialogtitle2;
wxPoint  * wxDialogwxDialogpos3;
wxSize  * wxDialogwxDialogsize4;
long  * wxDialogwxDialogstyle5;
wxString  * wxDialogwxDialogname6;
wxDialog * newwxDialog1 = new wxDialog( * wxDialogwxDialogparent0,  * wxDialogwxDialogid1,  * wxDialogwxDialogtitle2,  * wxDialogwxDialogpos3,  * wxDialogwxDialogsize4,  * wxDialogwxDialogstyle5,  * wxDialogwxDialogname6);
// Looking at method wxDialog::Centre
int  * wxDialogCentredirection0;
mywxDialog->Centre( * wxDialogCentredirection0);
// Looking at method wxDialog::Create
wxWindow*  * wxDialogCreateparent0;
wxWindowID  * wxDialogCreateid1;
wxString  * wxDialogCreatetitle2;
wxPoint  * wxDialogCreatepos3;
wxSize  * wxDialogCreatesize4;
long  * wxDialogCreatestyle5;
wxString  * wxDialogCreatename6;
bool retwxDialogCreate0 = mywxDialog->Create( * wxDialogCreateparent0,  * wxDialogCreateid1,  * wxDialogCreatetitle2,  * wxDialogCreatepos3,  * wxDialogCreatesize4,  * wxDialogCreatestyle5,  * wxDialogCreatename6);
// Looking at method wxDialog::CreateButtonSizer
long  * wxDialogCreateButtonSizerflags0;
wxSizer* retwxDialogCreateButtonSizer0 = mywxDialog->CreateButtonSizer( * wxDialogCreateButtonSizerflags0);
// Looking at method wxDialog::CreateStdDialogButtonSizer
long  * wxDialogCreateStdDialogButtonSizerflags0;
wxStdDialogButtonSizer* retwxDialogCreateStdDialogButtonSizer0 = mywxDialog->CreateStdDialogButtonSizer( * wxDialogCreateStdDialogButtonSizerflags0);
// Looking at method wxDialog::EndModal
int  * wxDialogEndModalretCode0;
mywxDialog->EndModal( * wxDialogEndModalretCode0);
// Looking at method wxDialog::GetReturnCode
int retwxDialogGetReturnCode0 = mywxDialog->GetReturnCode();
// Looking at method wxDialog::GetTitle
wxString retwxDialogGetTitle0 = mywxDialog->GetTitle();
// Looking at method wxDialog::Iconize
bool  * wxDialogIconizeiconize0;
mywxDialog->Iconize( * wxDialogIconizeiconize0);
// Looking at method wxDialog::IsIconized
bool retwxDialogIsIconized0 = mywxDialog->IsIconized();
// Looking at method wxDialog::IsModal
bool retwxDialogIsModal0 = mywxDialog->IsModal();
// Looking at method wxDialog::OnApply
wxCommandEvent  * wxDialogOnApplyevent0;
mywxDialog->OnApply( * wxDialogOnApplyevent0);
// Looking at method wxDialog::OnCancel
wxCommandEvent  * wxDialogOnCancelevent0;
mywxDialog->OnCancel( * wxDialogOnCancelevent0);
// Looking at method wxDialog::OnOK
wxCommandEvent  * wxDialogOnOKevent0;
mywxDialog->OnOK( * wxDialogOnOKevent0);
// Looking at method wxDialog::OnSysColourChanged
wxSysColourChangedEvent  * wxDialogOnSysColourChangedevent0;
mywxDialog->OnSysColourChanged( * wxDialogOnSysColourChangedevent0);
// Looking at method wxDialog::SetIcon
wxIcon  * wxDialogSetIconicon0;
mywxDialog->SetIcon( * wxDialogSetIconicon0);
// Looking at method wxDialog::SetIcons
wxIconBundle  * wxDialogSetIconsicons0;
mywxDialog->SetIcons( * wxDialogSetIconsicons0);
// Looking at method wxDialog::SetModal
bool  * wxDialogSetModalflag0;
mywxDialog->SetModal( * wxDialogSetModalflag0);
// Looking at method wxDialog::SetReturnCode
int  * wxDialogSetReturnCoderetCode0;
mywxDialog->SetReturnCode( * wxDialogSetReturnCoderetCode0);
// Looking at method wxDialog::SetTitle
wxString   * wxDialogSetTitletitle0;
mywxDialog->SetTitle( * wxDialogSetTitletitle0);
// Looking at method wxDialog::Show
bool  * wxDialogShowshow0;
bool retwxDialogShow0 = mywxDialog->Show( * wxDialogShowshow0);
// Looking at method wxDialog::ShowModal
int retwxDialogShowModal0 = mywxDialog->ShowModal();

// Looking at class wxDir
wxDir * mywxDir;
// Looking at method wxDir::wxDir
wxDir * newwxDir0 = new wxDir();
wxString  * wxDirwxDirdir0;
wxDir * newwxDir1 = new wxDir( * wxDirwxDirdir0);
// Looking at method wxDir::Exists
wxString  * wxDirExistsdir0;
static bool retwxDirExists0 = mywxDir->Exists( * wxDirExistsdir0);
// Looking at method wxDir::GetAllFiles
wxString  * wxDirGetAllFilesdirname0;
wxArrayString * * wxDirGetAllFilesfiles1;
wxString  * wxDirGetAllFilesfilespec2;
int  * wxDirGetAllFilesflags3;
static size_t retwxDirGetAllFiles0 = mywxDir->GetAllFiles( * wxDirGetAllFilesdirname0,  * wxDirGetAllFilesfiles1,  * wxDirGetAllFilesfilespec2,  * wxDirGetAllFilesflags3);
// Looking at method wxDir::GetFirst
wxString*  * wxDirGetFirstfilename0;
wxString  * wxDirGetFirstfilespec1;
int  * wxDirGetFirstflags2;
bool retwxDirGetFirst0 = mywxDir->GetFirst( * wxDirGetFirstfilename0,  * wxDirGetFirstfilespec1,  * wxDirGetFirstflags2);
// Looking at method wxDir::GetName
wxString retwxDirGetName0 = mywxDir->GetName();
// Looking at method wxDir::GetNext
wxString*  * wxDirGetNextfilename0;
bool retwxDirGetNext0 = mywxDir->GetNext( * wxDirGetNextfilename0);
// Looking at method wxDir::HasFiles
wxString  * wxDirHasFilesfilespec0;
bool retwxDirHasFiles0 = mywxDir->HasFiles( * wxDirHasFilesfilespec0);
// Looking at method wxDir::HasSubDirs
wxString  * wxDirHasSubDirsdirspec0;
bool retwxDirHasSubDirs0 = mywxDir->HasSubDirs( * wxDirHasSubDirsdirspec0);
// Looking at method wxDir::IsOpened
bool retwxDirIsOpened0 = mywxDir->IsOpened();
// Looking at method wxDir::Open
wxString  * wxDirOpendir0;
bool retwxDirOpen0 = mywxDir->Open( * wxDirOpendir0);
// Looking at method wxDir::Traverse
wxDirTraverser  * wxDirTraversesink0;
wxString  * wxDirTraversefilespec1;
int  * wxDirTraverseflags2;
size_t retwxDirTraverse0 = mywxDir->Traverse( * wxDirTraversesink0,  * wxDirTraversefilespec1,  * wxDirTraverseflags2);

// Looking at class wxDirDialog
wxDirDialog * mywxDirDialog;
// Looking at method wxDirDialog::wxDirDialog
wxWindow*  * wxDirDialogwxDirDialogparent0;
wxString  * wxDirDialogwxDirDialogmessage1;
wxString  * wxDirDialogwxDirDialogdefaultPath2;
long  * wxDirDialogwxDirDialogstyle3;
wxPoint  * wxDirDialogwxDirDialogpos4;
wxSize  * wxDirDialogwxDirDialogsize5;
wxString  * wxDirDialogwxDirDialogname6;
wxDirDialog * newwxDirDialog0 = new wxDirDialog( * wxDirDialogwxDirDialogparent0,  * wxDirDialogwxDirDialogmessage1,  * wxDirDialogwxDirDialogdefaultPath2,  * wxDirDialogwxDirDialogstyle3,  * wxDirDialogwxDirDialogpos4,  * wxDirDialogwxDirDialogsize5,  * wxDirDialogwxDirDialogname6);
// Looking at method wxDirDialog::GetPath
wxString retwxDirDialogGetPath0 = mywxDirDialog->GetPath();
// Looking at method wxDirDialog::GetMessage
wxString retwxDirDialogGetMessage0 = mywxDirDialog->GetMessage();
// Looking at method wxDirDialog::GetStyle
long retwxDirDialogGetStyle0 = mywxDirDialog->GetStyle();
// Looking at method wxDirDialog::SetMessage
wxString  * wxDirDialogSetMessagemessage0;
mywxDirDialog->SetMessage( * wxDirDialogSetMessagemessage0);
// Looking at method wxDirDialog::SetPath
wxString  * wxDirDialogSetPathpath0;
mywxDirDialog->SetPath( * wxDirDialogSetPathpath0);
// Looking at method wxDirDialog::SetStyle
long  * wxDirDialogSetStylestyle0;
mywxDirDialog->SetStyle( * wxDirDialogSetStylestyle0);
// Looking at method wxDirDialog::ShowModal
int retwxDirDialogShowModal0 = mywxDirDialog->ShowModal();

// Looking at class wxDirTraverser
wxDirTraverser * mywxDirTraverser;
// Looking at method wxDirTraverser::OnDir
// Looking at method wxDirTraverser::OnFile
// Looking at method wxDirTraverser::OnOpenError

// Looking at class wxDisplay
wxDisplay * mywxDisplay;
// Looking at method wxDisplay::wxDisplay
size_t  * wxDisplaywxDisplayindex0;
wxDisplay * newwxDisplay0 = new wxDisplay( * wxDisplaywxDisplayindex0);
// Looking at method wxDisplay::ChangeMode
wxVideoMode  * wxDisplayChangeModemode0;
bool  retwxDisplayChangeMode0 = mywxDisplay->ChangeMode( * wxDisplayChangeModemode0);
// Looking at method wxDisplay::GetCount
static size_t retwxDisplayGetCount0 = mywxDisplay->GetCount();
// Looking at method wxDisplay::GetCurrentMode
wxVideoMode  retwxDisplayGetCurrentMode0 = mywxDisplay->GetCurrentMode();
// Looking at method wxDisplay::GetDepth
int  retwxDisplayGetDepth0 = mywxDisplay->GetDepth();
// Looking at method wxDisplay::GetFromPoint
wxPoint  * wxDisplayGetFromPointpt0;
static int retwxDisplayGetFromPoint0 = mywxDisplay->GetFromPoint( * wxDisplayGetFromPointpt0);
// Looking at method wxDisplay::GetGeometry
wxRect  retwxDisplayGetGeometry0 = mywxDisplay->GetGeometry();
// Looking at method wxDisplay::GetModes
wxVideoMode  * wxDisplayGetModesmode0;
wxArrayVideoModes  retwxDisplayGetModes0 = mywxDisplay->GetModes( * wxDisplayGetModesmode0);
// Looking at method wxDisplay::GetName
wxString  retwxDisplayGetName0 = mywxDisplay->GetName();
// Looking at method wxDisplay::IsPrimary
bool  retwxDisplayIsPrimary0 = mywxDisplay->IsPrimary();

// Looking at class wxDocChildFrame
wxDocChildFrame * mywxDocChildFrame;
// Looking at method wxDocChildFrame::m_childDocument
// Looking at method wxDocChildFrame::m_childView
// Looking at method wxDocChildFrame::wxDocChildFrame
wxDocument*  * wxDocChildFramewxDocChildFramedoc0;
wxView*  * wxDocChildFramewxDocChildFrameview1;
wxFrame*  * wxDocChildFramewxDocChildFrameparent2;
wxWindowID  * wxDocChildFramewxDocChildFrameid3;
wxString  * wxDocChildFramewxDocChildFrametitle4;
wxPoint  * wxDocChildFramewxDocChildFramepos5;
wxSize  * wxDocChildFramewxDocChildFramesize6;
long  * wxDocChildFramewxDocChildFramestyle7;
wxString  * wxDocChildFramewxDocChildFramename8;
wxDocChildFrame * newwxDocChildFrame0 = new wxDocChildFrame( * wxDocChildFramewxDocChildFramedoc0,  * wxDocChildFramewxDocChildFrameview1,  * wxDocChildFramewxDocChildFrameparent2,  * wxDocChildFramewxDocChildFrameid3,  * wxDocChildFramewxDocChildFrametitle4,  * wxDocChildFramewxDocChildFramepos5,  * wxDocChildFramewxDocChildFramesize6,  * wxDocChildFramewxDocChildFramestyle7,  * wxDocChildFramewxDocChildFramename8);
// Looking at method wxDocChildFrame::GetDocument
wxDocument* retwxDocChildFrameGetDocument0 = mywxDocChildFrame->GetDocument();
// Looking at method wxDocChildFrame::GetView
wxView* retwxDocChildFrameGetView0 = mywxDocChildFrame->GetView();
// Looking at method wxDocChildFrame::OnActivate
wxActivateEvent  * wxDocChildFrameOnActivateevent0;
mywxDocChildFrame->OnActivate( * wxDocChildFrameOnActivateevent0);
// Looking at method wxDocChildFrame::OnCloseWindow
wxCloseEvent  * wxDocChildFrameOnCloseWindowevent0;
mywxDocChildFrame->OnCloseWindow( * wxDocChildFrameOnCloseWindowevent0);
// Looking at method wxDocChildFrame::SetDocument
wxDocument * * wxDocChildFrameSetDocumentdoc0;
mywxDocChildFrame->SetDocument( * wxDocChildFrameSetDocumentdoc0);
// Looking at method wxDocChildFrame::SetView
wxView * * wxDocChildFrameSetViewview0;
mywxDocChildFrame->SetView( * wxDocChildFrameSetViewview0);

// Looking at class wxDocMDIChildFrame
wxDocMDIChildFrame * mywxDocMDIChildFrame;
// Looking at method wxDocMDIChildFrame::m_childDocument
// Looking at method wxDocMDIChildFrame::m_childView
// Looking at method wxDocMDIChildFrame::wxDocMDIChildFrame
wxDocument*  * wxDocMDIChildFramewxDocMDIChildFramedoc0;
wxView*  * wxDocMDIChildFramewxDocMDIChildFrameview1;
wxFrame*  * wxDocMDIChildFramewxDocMDIChildFrameparent2;
wxWindowID  * wxDocMDIChildFramewxDocMDIChildFrameid3;
wxString  * wxDocMDIChildFramewxDocMDIChildFrametitle4;
wxPoint  * wxDocMDIChildFramewxDocMDIChildFramepos5;
wxSize  * wxDocMDIChildFramewxDocMDIChildFramesize6;
long  * wxDocMDIChildFramewxDocMDIChildFramestyle7;
wxString  * wxDocMDIChildFramewxDocMDIChildFramename8;
wxDocMDIChildFrame * newwxDocMDIChildFrame0 = new wxDocMDIChildFrame( * wxDocMDIChildFramewxDocMDIChildFramedoc0,  * wxDocMDIChildFramewxDocMDIChildFrameview1,  * wxDocMDIChildFramewxDocMDIChildFrameparent2,  * wxDocMDIChildFramewxDocMDIChildFrameid3,  * wxDocMDIChildFramewxDocMDIChildFrametitle4,  * wxDocMDIChildFramewxDocMDIChildFramepos5,  * wxDocMDIChildFramewxDocMDIChildFramesize6,  * wxDocMDIChildFramewxDocMDIChildFramestyle7,  * wxDocMDIChildFramewxDocMDIChildFramename8);
// Looking at method wxDocMDIChildFrame::GetDocument
wxDocument* retwxDocMDIChildFrameGetDocument0 = mywxDocMDIChildFrame->GetDocument();
// Looking at method wxDocMDIChildFrame::GetView
wxView* retwxDocMDIChildFrameGetView0 = mywxDocMDIChildFrame->GetView();
// Looking at method wxDocMDIChildFrame::OnActivate
wxActivateEvent  * wxDocMDIChildFrameOnActivateevent0;
mywxDocMDIChildFrame->OnActivate( * wxDocMDIChildFrameOnActivateevent0);
// Looking at method wxDocMDIChildFrame::OnCloseWindow
wxCloseEvent  * wxDocMDIChildFrameOnCloseWindowevent0;
mywxDocMDIChildFrame->OnCloseWindow( * wxDocMDIChildFrameOnCloseWindowevent0);
// Looking at method wxDocMDIChildFrame::SetDocument
wxDocument * * wxDocMDIChildFrameSetDocumentdoc0;
mywxDocMDIChildFrame->SetDocument( * wxDocMDIChildFrameSetDocumentdoc0);
// Looking at method wxDocMDIChildFrame::SetView
wxView * * wxDocMDIChildFrameSetViewview0;
mywxDocMDIChildFrame->SetView( * wxDocMDIChildFrameSetViewview0);

// Looking at class wxDocMDIParentFrame
wxDocMDIParentFrame * mywxDocMDIParentFrame;
// Looking at method wxDocMDIParentFrame::wxDocMDIParentFrame
wxDocManager*  * wxDocMDIParentFramewxDocMDIParentFramemanager0;
wxFrame * * wxDocMDIParentFramewxDocMDIParentFrameparent1;
wxWindowID  * wxDocMDIParentFramewxDocMDIParentFrameid2;
wxString  * wxDocMDIParentFramewxDocMDIParentFrametitle3;
wxPoint  * wxDocMDIParentFramewxDocMDIParentFramepos4;
wxSize  * wxDocMDIParentFramewxDocMDIParentFramesize5;
long  * wxDocMDIParentFramewxDocMDIParentFramestyle6;
wxString  * wxDocMDIParentFramewxDocMDIParentFramename7;
wxDocMDIParentFrame * newwxDocMDIParentFrame0 = new wxDocMDIParentFrame( * wxDocMDIParentFramewxDocMDIParentFramemanager0,  * wxDocMDIParentFramewxDocMDIParentFrameparent1,  * wxDocMDIParentFramewxDocMDIParentFrameid2,  * wxDocMDIParentFramewxDocMDIParentFrametitle3,  * wxDocMDIParentFramewxDocMDIParentFramepos4,  * wxDocMDIParentFramewxDocMDIParentFramesize5,  * wxDocMDIParentFramewxDocMDIParentFramestyle6,  * wxDocMDIParentFramewxDocMDIParentFramename7);
// Looking at method wxDocMDIParentFrame::OnCloseWindow
wxCloseEvent  * wxDocMDIParentFrameOnCloseWindowevent0;
mywxDocMDIParentFrame->OnCloseWindow( * wxDocMDIParentFrameOnCloseWindowevent0);

// Looking at class wxDocManager
wxDocManager * mywxDocManager;
// Looking at method wxDocManager::m_currentView
// Looking at method wxDocManager::m_defaultDocumentNameCounter
// Looking at method wxDocManager::m_fileHistory
// Looking at method wxDocManager::m_maxDocsOpen
// Looking at method wxDocManager::m_docs
// Looking at method wxDocManager::m_flags
// Looking at method wxDocManager::m_lastDirectory
// Looking at method wxDocManager::m_templates
// Looking at method wxDocManager::wxDocManager
long  * wxDocManagerwxDocManagerflags0;
bool  * wxDocManagerwxDocManagerinitialize1;
wxDocManager * newwxDocManager0 = new wxDocManager( * wxDocManagerwxDocManagerflags0,  * wxDocManagerwxDocManagerinitialize1);
// Looking at method wxDocManager::ActivateView
wxView*  * wxDocManagerActivateViewdoc0;
bool  * wxDocManagerActivateViewactivate1;
mywxDocManager->ActivateView( * wxDocManagerActivateViewdoc0,  * wxDocManagerActivateViewactivate1);
// Looking at method wxDocManager::AddDocument
wxDocument * * wxDocManagerAddDocumentdoc0;
mywxDocManager->AddDocument( * wxDocManagerAddDocumentdoc0);
// Looking at method wxDocManager::AddFileToHistory
wxString  * wxDocManagerAddFileToHistoryfilename0;
mywxDocManager->AddFileToHistory( * wxDocManagerAddFileToHistoryfilename0);
// Looking at method wxDocManager::AssociateTemplate
wxDocTemplate * * wxDocManagerAssociateTemplatetemp0;
mywxDocManager->AssociateTemplate( * wxDocManagerAssociateTemplatetemp0);
// Looking at method wxDocManager::CloseDocuments
bool  * wxDocManagerCloseDocumentsforce0;
bool retwxDocManagerCloseDocuments0 = mywxDocManager->CloseDocuments( * wxDocManagerCloseDocumentsforce0);
// Looking at method wxDocManager::CreateDocument
wxString  * wxDocManagerCreateDocumentpath0;
long  * wxDocManagerCreateDocumentflags1;
wxDocument* retwxDocManagerCreateDocument0 = mywxDocManager->CreateDocument( * wxDocManagerCreateDocumentpath0,  * wxDocManagerCreateDocumentflags1);
// Looking at method wxDocManager::CreateView
wxDocument* * wxDocManagerCreateViewdoc0;
long  * wxDocManagerCreateViewflags1;
wxView* retwxDocManagerCreateView0 = mywxDocManager->CreateView( * wxDocManagerCreateViewdoc0,  * wxDocManagerCreateViewflags1);
// Looking at method wxDocManager::DisassociateTemplate
wxDocTemplate * * wxDocManagerDisassociateTemplatetemp0;
mywxDocManager->DisassociateTemplate( * wxDocManagerDisassociateTemplatetemp0);
// Looking at method wxDocManager::FileHistoryAddFilesToMenu
mywxDocManager->FileHistoryAddFilesToMenu();
wxMenu*  * wxDocManagerFileHistoryAddFilesToMenumenu0;
mywxDocManager->FileHistoryAddFilesToMenu( * wxDocManagerFileHistoryAddFilesToMenumenu0);
// Looking at method wxDocManager::FileHistoryLoad
wxConfigBase  * wxDocManagerFileHistoryLoadconfig0;
mywxDocManager->FileHistoryLoad( * wxDocManagerFileHistoryLoadconfig0);
// Looking at method wxDocManager::FileHistoryRemoveMenu
wxMenu*  * wxDocManagerFileHistoryRemoveMenumenu0;
mywxDocManager->FileHistoryRemoveMenu( * wxDocManagerFileHistoryRemoveMenumenu0);
// Looking at method wxDocManager::FileHistorySave
wxConfigBase  * wxDocManagerFileHistorySaveresourceFile0;
mywxDocManager->FileHistorySave( * wxDocManagerFileHistorySaveresourceFile0);
// Looking at method wxDocManager::FileHistoryUseMenu
wxMenu*  * wxDocManagerFileHistoryUseMenumenu0;
mywxDocManager->FileHistoryUseMenu( * wxDocManagerFileHistoryUseMenumenu0);
// Looking at method wxDocManager::FindTemplateForPath
wxString  * wxDocManagerFindTemplateForPathpath0;
wxDocTemplate * retwxDocManagerFindTemplateForPath0 = mywxDocManager->FindTemplateForPath( * wxDocManagerFindTemplateForPathpath0);
// Looking at method wxDocManager::GetCurrentDocument
wxDocument * retwxDocManagerGetCurrentDocument0 = mywxDocManager->GetCurrentDocument();
// Looking at method wxDocManager::GetCurrentView
wxView * retwxDocManagerGetCurrentView0 = mywxDocManager->GetCurrentView();
// Looking at method wxDocManager::GetDocuments
wxList retwxDocManagerGetDocuments0 = mywxDocManager->GetDocuments();
// Looking at method wxDocManager::GetFileHistory
wxFileHistory * retwxDocManagerGetFileHistory0 = mywxDocManager->GetFileHistory();
// Looking at method wxDocManager::GetLastDirectory
wxString retwxDocManagerGetLastDirectory0 = mywxDocManager->GetLastDirectory();
// Looking at method wxDocManager::GetMaxDocsOpen
int retwxDocManagerGetMaxDocsOpen0 = mywxDocManager->GetMaxDocsOpen();
// Looking at method wxDocManager::GetHistoryFilesCount
size_t retwxDocManagerGetHistoryFilesCount0 = mywxDocManager->GetHistoryFilesCount();
// Looking at method wxDocManager::Initialize
bool retwxDocManagerInitialize0 = mywxDocManager->Initialize();
// Looking at method wxDocManager::MakeDefaultName
wxString  * wxDocManagerMakeDefaultNamebuf0;
bool retwxDocManagerMakeDefaultName0 = mywxDocManager->MakeDefaultName( * wxDocManagerMakeDefaultNamebuf0);
// Looking at method wxDocManager::OnCreateFileHistory
wxFileHistory * retwxDocManagerOnCreateFileHistory0 = mywxDocManager->OnCreateFileHistory();
// Looking at method wxDocManager::OnFileClose
wxCommandEvent  * wxDocManagerOnFileCloseevent0;
mywxDocManager->OnFileClose( * wxDocManagerOnFileCloseevent0);
// Looking at method wxDocManager::OnFileCloseAll
wxCommandEvent  * wxDocManagerOnFileCloseAllevent0;
mywxDocManager->OnFileCloseAll( * wxDocManagerOnFileCloseAllevent0);
// Looking at method wxDocManager::OnFileNew
wxCommandEvent  * wxDocManagerOnFileNewevent0;
mywxDocManager->OnFileNew( * wxDocManagerOnFileNewevent0);
// Looking at method wxDocManager::OnFileOpen
wxCommandEvent  * wxDocManagerOnFileOpenevent0;
mywxDocManager->OnFileOpen( * wxDocManagerOnFileOpenevent0);
// Looking at method wxDocManager::OnFileRevert
wxCommandEvent  * wxDocManagerOnFileRevertevent0;
mywxDocManager->OnFileRevert( * wxDocManagerOnFileRevertevent0);
// Looking at method wxDocManager::OnFileSave
wxCommandEvent  * wxDocManagerOnFileSaveevent0;
mywxDocManager->OnFileSave( * wxDocManagerOnFileSaveevent0);
// Looking at method wxDocManager::OnFileSaveAs
wxCommandEvent  * wxDocManagerOnFileSaveAsevent0;
mywxDocManager->OnFileSaveAs( * wxDocManagerOnFileSaveAsevent0);
// Looking at method wxDocManager::RemoveDocument
wxDocument * * wxDocManagerRemoveDocumentdoc0;
mywxDocManager->RemoveDocument( * wxDocManagerRemoveDocumentdoc0);
// Looking at method wxDocManager::SelectDocumentPath
wxDocTemplate ** * wxDocManagerSelectDocumentPathtemplates0;
int  * wxDocManagerSelectDocumentPathnoTemplates1;
wxString  * wxDocManagerSelectDocumentPathpath2;
long  * wxDocManagerSelectDocumentPathflags3;
bool  * wxDocManagerSelectDocumentPathsave4;
wxDocTemplate * retwxDocManagerSelectDocumentPath0 = mywxDocManager->SelectDocumentPath( * wxDocManagerSelectDocumentPathtemplates0,  * wxDocManagerSelectDocumentPathnoTemplates1,  * wxDocManagerSelectDocumentPathpath2,  * wxDocManagerSelectDocumentPathflags3,  * wxDocManagerSelectDocumentPathsave4);
// Looking at method wxDocManager::SelectDocumentType
wxDocTemplate ** * wxDocManagerSelectDocumentTypetemplates0;
int  * wxDocManagerSelectDocumentTypenoTemplates1;
bool  * wxDocManagerSelectDocumentTypesort2;
wxDocTemplate * retwxDocManagerSelectDocumentType0 = mywxDocManager->SelectDocumentType( * wxDocManagerSelectDocumentTypetemplates0,  * wxDocManagerSelectDocumentTypenoTemplates1,  * wxDocManagerSelectDocumentTypesort2);
// Looking at method wxDocManager::SelectViewType
wxDocTemplate ** * wxDocManagerSelectViewTypetemplates0;
int  * wxDocManagerSelectViewTypenoTemplates1;
bool  * wxDocManagerSelectViewTypesort2;
wxDocTemplate * retwxDocManagerSelectViewType0 = mywxDocManager->SelectViewType( * wxDocManagerSelectViewTypetemplates0,  * wxDocManagerSelectViewTypenoTemplates1,  * wxDocManagerSelectViewTypesort2);
// Looking at method wxDocManager::SetLastDirectory
wxString  * wxDocManagerSetLastDirectorydir0;
mywxDocManager->SetLastDirectory( * wxDocManagerSetLastDirectorydir0);
// Looking at method wxDocManager::SetMaxDocsOpen
int  * wxDocManagerSetMaxDocsOpenn0;
mywxDocManager->SetMaxDocsOpen( * wxDocManagerSetMaxDocsOpenn0);

// Looking at class wxDocParentFrame
wxDocParentFrame * mywxDocParentFrame;
// Looking at method wxDocParentFrame::wxDocParentFrame
wxDocManager*  * wxDocParentFramewxDocParentFramemanager0;
wxFrame * * wxDocParentFramewxDocParentFrameparent1;
wxWindowID  * wxDocParentFramewxDocParentFrameid2;
wxString  * wxDocParentFramewxDocParentFrametitle3;
wxPoint  * wxDocParentFramewxDocParentFramepos4;
wxSize  * wxDocParentFramewxDocParentFramesize5;
long  * wxDocParentFramewxDocParentFramestyle6;
wxString  * wxDocParentFramewxDocParentFramename7;
wxDocParentFrame * newwxDocParentFrame0 = new wxDocParentFrame( * wxDocParentFramewxDocParentFramemanager0,  * wxDocParentFramewxDocParentFrameparent1,  * wxDocParentFramewxDocParentFrameid2,  * wxDocParentFramewxDocParentFrametitle3,  * wxDocParentFramewxDocParentFramepos4,  * wxDocParentFramewxDocParentFramesize5,  * wxDocParentFramewxDocParentFramestyle6,  * wxDocParentFramewxDocParentFramename7);
// Looking at method wxDocParentFrame::OnCloseWindow
wxCloseEvent  * wxDocParentFrameOnCloseWindowevent0;
mywxDocParentFrame->OnCloseWindow( * wxDocParentFrameOnCloseWindowevent0);

// Looking at class wxDocTemplate
wxDocTemplate * mywxDocTemplate;
// Looking at method wxDocTemplate::m_defaultExt
// Looking at method wxDocTemplate::m_description
// Looking at method wxDocTemplate::m_directory
// Looking at method wxDocTemplate::m_docClassInfo
// Looking at method wxDocTemplate::m_docTypeName
// Looking at method wxDocTemplate::m_documentManager
// Looking at method wxDocTemplate::m_fileFilter
// Looking at method wxDocTemplate::m_flags
// Looking at method wxDocTemplate::m_viewClassInfo
// Looking at method wxDocTemplate::m_viewTypeName
// Looking at method wxDocTemplate::wxDocTemplate
wxDocManager*  * wxDocTemplatewxDocTemplatemanager0;
wxString  * wxDocTemplatewxDocTemplatedescr1;
wxString  * wxDocTemplatewxDocTemplatefilter2;
wxString  * wxDocTemplatewxDocTemplatedir3;
wxString  * wxDocTemplatewxDocTemplateext4;
wxString  * wxDocTemplatewxDocTemplatedocTypeName5;
wxString  * wxDocTemplatewxDocTemplateviewTypeName6;
wxClassInfo*  * wxDocTemplatewxDocTemplatedocClassInfo7;
wxClassInfo*  * wxDocTemplatewxDocTemplateviewClassInfo8;
long  * wxDocTemplatewxDocTemplateflags9;
wxDocTemplate * newwxDocTemplate0 = new wxDocTemplate( * wxDocTemplatewxDocTemplatemanager0,  * wxDocTemplatewxDocTemplatedescr1,  * wxDocTemplatewxDocTemplatefilter2,  * wxDocTemplatewxDocTemplatedir3,  * wxDocTemplatewxDocTemplateext4,  * wxDocTemplatewxDocTemplatedocTypeName5,  * wxDocTemplatewxDocTemplateviewTypeName6,  * wxDocTemplatewxDocTemplatedocClassInfo7,  * wxDocTemplatewxDocTemplateviewClassInfo8,  * wxDocTemplatewxDocTemplateflags9);
// Looking at method wxDocTemplate::CreateDocument
wxString  * wxDocTemplateCreateDocumentpath0;
long  * wxDocTemplateCreateDocumentflags1;
wxDocument * retwxDocTemplateCreateDocument0 = mywxDocTemplate->CreateDocument( * wxDocTemplateCreateDocumentpath0,  * wxDocTemplateCreateDocumentflags1);
// Looking at method wxDocTemplate::CreateView
wxDocument * * wxDocTemplateCreateViewdoc0;
long  * wxDocTemplateCreateViewflags1;
wxView * retwxDocTemplateCreateView0 = mywxDocTemplate->CreateView( * wxDocTemplateCreateViewdoc0,  * wxDocTemplateCreateViewflags1);
// Looking at method wxDocTemplate::GetDefaultExtension
wxString retwxDocTemplateGetDefaultExtension0 = mywxDocTemplate->GetDefaultExtension();
// Looking at method wxDocTemplate::GetDescription
wxString retwxDocTemplateGetDescription0 = mywxDocTemplate->GetDescription();
// Looking at method wxDocTemplate::GetDirectory
wxString retwxDocTemplateGetDirectory0 = mywxDocTemplate->GetDirectory();
// Looking at method wxDocTemplate::GetDocumentManager
wxDocManager * retwxDocTemplateGetDocumentManager0 = mywxDocTemplate->GetDocumentManager();
// Looking at method wxDocTemplate::GetDocumentName
wxString retwxDocTemplateGetDocumentName0 = mywxDocTemplate->GetDocumentName();
// Looking at method wxDocTemplate::GetFileFilter
wxString retwxDocTemplateGetFileFilter0 = mywxDocTemplate->GetFileFilter();
// Looking at method wxDocTemplate::GetFlags
long retwxDocTemplateGetFlags0 = mywxDocTemplate->GetFlags();
// Looking at method wxDocTemplate::GetViewName
wxString retwxDocTemplateGetViewName0 = mywxDocTemplate->GetViewName();
// Looking at method wxDocTemplate::InitDocument
wxDocument*  * wxDocTemplateInitDocumentdoc0;
wxString  * wxDocTemplateInitDocumentpath1;
long  * wxDocTemplateInitDocumentflags2;
bool retwxDocTemplateInitDocument0 = mywxDocTemplate->InitDocument( * wxDocTemplateInitDocumentdoc0,  * wxDocTemplateInitDocumentpath1,  * wxDocTemplateInitDocumentflags2);
// Looking at method wxDocTemplate::IsVisible
bool retwxDocTemplateIsVisible0 = mywxDocTemplate->IsVisible();
// Looking at method wxDocTemplate::SetDefaultExtension
wxString  * wxDocTemplateSetDefaultExtensionext0;
mywxDocTemplate->SetDefaultExtension( * wxDocTemplateSetDefaultExtensionext0);
// Looking at method wxDocTemplate::SetDescription
wxString  * wxDocTemplateSetDescriptiondescr0;
mywxDocTemplate->SetDescription( * wxDocTemplateSetDescriptiondescr0);
// Looking at method wxDocTemplate::SetDirectory
wxString  * wxDocTemplateSetDirectorydir0;
mywxDocTemplate->SetDirectory( * wxDocTemplateSetDirectorydir0);
// Looking at method wxDocTemplate::SetDocumentManager
wxDocManager * * wxDocTemplateSetDocumentManagermanager0;
mywxDocTemplate->SetDocumentManager( * wxDocTemplateSetDocumentManagermanager0);
// Looking at method wxDocTemplate::SetFileFilter
wxString  * wxDocTemplateSetFileFilterfilter0;
mywxDocTemplate->SetFileFilter( * wxDocTemplateSetFileFilterfilter0);
// Looking at method wxDocTemplate::SetFlags
long  * wxDocTemplateSetFlagsflags0;
mywxDocTemplate->SetFlags( * wxDocTemplateSetFlagsflags0);

// Looking at class wxDocument
wxDocument * mywxDocument;
// Looking at method wxDocument::m_commandProcessor
// Looking at method wxDocument::m_documentFile
// Looking at method wxDocument::m_documentModified
// Looking at method wxDocument::m_documentTemplate
// Looking at method wxDocument::m_documentTitle
// Looking at method wxDocument::m_documentTypeName
// Looking at method wxDocument::m_documentViews
// Looking at method wxDocument::wxDocument
wxDocument * newwxDocument0 = new wxDocument();
// Looking at method wxDocument::AddView
// Looking at method wxDocument::Close
// Looking at method wxDocument::DeleteAllViews
// Looking at method wxDocument::GetCommandProcessor
wxCommandProcessor* retwxDocumentGetCommandProcessor0 = mywxDocument->GetCommandProcessor();
// Looking at method wxDocument::GetDocumentTemplate
wxDocTemplate* retwxDocumentGetDocumentTemplate0 = mywxDocument->GetDocumentTemplate();
// Looking at method wxDocument::GetDocumentManager
wxDocManager* retwxDocumentGetDocumentManager0 = mywxDocument->GetDocumentManager();
// Looking at method wxDocument::GetDocumentName
wxString retwxDocumentGetDocumentName0 = mywxDocument->GetDocumentName();
// Looking at method wxDocument::GetDocumentWindow
wxWindow* retwxDocumentGetDocumentWindow0 = mywxDocument->GetDocumentWindow();
// Looking at method wxDocument::GetFilename
wxString retwxDocumentGetFilename0 = mywxDocument->GetFilename();
// Looking at method wxDocument::GetFirstView
wxView * retwxDocumentGetFirstView0 = mywxDocument->GetFirstView();
// Looking at method wxDocument::GetPrintableName
// Looking at method wxDocument::GetTitle
wxString retwxDocumentGetTitle0 = mywxDocument->GetTitle();
// Looking at method wxDocument::GetViews
wxList  retwxDocumentGetViews0 = mywxDocument->GetViews();
// Looking at method wxDocument::IsModified
// Looking at method wxDocument::LoadObject
// Looking at method wxDocument::Modify
// Looking at method wxDocument::OnChangedViewList
// Looking at method wxDocument::OnCloseDocument
// Looking at method wxDocument::OnCreate
// Looking at method wxDocument::OnCreateCommandProcessor
// Looking at method wxDocument::OnNewDocument
// Looking at method wxDocument::OnOpenDocument
// Looking at method wxDocument::OnSaveDocument
// Looking at method wxDocument::OnSaveModified
// Looking at method wxDocument::RemoveView
// Looking at method wxDocument::Save
// Looking at method wxDocument::SaveAs
// Looking at method wxDocument::SaveObject
// Looking at method wxDocument::SetCommandProcessor
// Looking at method wxDocument::SetDocumentName
wxString  * wxDocumentSetDocumentNamename0;
mywxDocument->SetDocumentName( * wxDocumentSetDocumentNamename0);
// Looking at method wxDocument::SetDocumentTemplate
wxDocTemplate*  * wxDocumentSetDocumentTemplatetempl0;
mywxDocument->SetDocumentTemplate( * wxDocumentSetDocumentTemplatetempl0);
// Looking at method wxDocument::SetFilename
wxString  * wxDocumentSetFilenamefilename0;
bool  * wxDocumentSetFilenamenotifyViews1;
mywxDocument->SetFilename( * wxDocumentSetFilenamefilename0,  * wxDocumentSetFilenamenotifyViews1);
// Looking at method wxDocument::SetTitle
wxString  * wxDocumentSetTitletitle0;
mywxDocument->SetTitle( * wxDocumentSetTitletitle0);
// Looking at method wxDocument::UpdateAllViews
wxView*  * wxDocumentUpdateAllViewssender0;
wxObject*  * wxDocumentUpdateAllViewshint1;
mywxDocument->UpdateAllViews( * wxDocumentUpdateAllViewssender0,  * wxDocumentUpdateAllViewshint1);

// Looking at class wxDragImage
wxDragImage * mywxDragImage;
// Looking at method wxDragImage::wxDragImage
wxDragImage * newwxDragImage0 = new wxDragImage();
wxBitmap  * wxDragImagewxDragImageimage0;
wxCursor  * wxDragImagewxDragImagecursor1;
wxPoint  * wxDragImagewxDragImagecursorHotspot2;
wxDragImage * newwxDragImage1 = new wxDragImage( * wxDragImagewxDragImageimage0,  * wxDragImagewxDragImagecursor1,  * wxDragImagewxDragImagecursorHotspot2);
wxIcon  * wxDragImagewxDragImageimage3;
wxCursor  * wxDragImagewxDragImagecursor4;
wxPoint  * wxDragImagewxDragImagecursorHotspot5;
wxDragImage * newwxDragImage2 = new wxDragImage( * wxDragImagewxDragImageimage3,  * wxDragImagewxDragImagecursor4,  * wxDragImagewxDragImagecursorHotspot5);
wxString  * wxDragImagewxDragImagetext6;
wxCursor  * wxDragImagewxDragImagecursor7;
wxPoint  * wxDragImagewxDragImagecursorHotspot8;
wxDragImage * newwxDragImage3 = new wxDragImage( * wxDragImagewxDragImagetext6,  * wxDragImagewxDragImagecursor7,  * wxDragImagewxDragImagecursorHotspot8);
wxTreeCtrl  * wxDragImagewxDragImagetreeCtrl9;
wxTreeItemId  * wxDragImagewxDragImageid10;
wxDragImage * newwxDragImage4 = new wxDragImage( * wxDragImagewxDragImagetreeCtrl9,  * wxDragImagewxDragImageid10);
wxListCtrl  * wxDragImagewxDragImagetreeCtrl11;
long  * wxDragImagewxDragImageid12;
wxDragImage * newwxDragImage5 = new wxDragImage( * wxDragImagewxDragImagetreeCtrl11,  * wxDragImagewxDragImageid12);
wxCursor  * wxDragImagewxDragImagecursor13;
wxPoint  * wxDragImagewxDragImagecursorHotspot14;
wxDragImage * newwxDragImage6 = new wxDragImage( * wxDragImagewxDragImagecursor13,  * wxDragImagewxDragImagecursorHotspot14);
// Looking at method wxDragImage::BeginDrag
wxPoint  * wxDragImageBeginDraghotspot0;
wxWindow*  * wxDragImageBeginDragwindow1;
bool  * wxDragImageBeginDragfullScreen2;
wxRect*  * wxDragImageBeginDragrect3;
bool retwxDragImageBeginDrag0 = mywxDragImage->BeginDrag( * wxDragImageBeginDraghotspot0,  * wxDragImageBeginDragwindow1,  * wxDragImageBeginDragfullScreen2,  * wxDragImageBeginDragrect3);
wxPoint  * wxDragImageBeginDraghotspot4;
wxWindow*  * wxDragImageBeginDragwindow5;
wxWindow*  * wxDragImageBeginDragboundingWindow6;
bool retwxDragImageBeginDrag1 = mywxDragImage->BeginDrag( * wxDragImageBeginDraghotspot4,  * wxDragImageBeginDragwindow5,  * wxDragImageBeginDragboundingWindow6);
// Looking at method wxDragImage::DoDrawImage
// Looking at method wxDragImage::EndDrag
bool retwxDragImageEndDrag0 = mywxDragImage->EndDrag();
// Looking at method wxDragImage::GetImageRect
// Looking at method wxDragImage::Hide
bool retwxDragImageHide0 = mywxDragImage->Hide();
// Looking at method wxDragImage::Move
wxPoint  * wxDragImageMovept0;
bool retwxDragImageMove0 = mywxDragImage->Move( * wxDragImageMovept0);
// Looking at method wxDragImage::Show
bool retwxDragImageShow0 = mywxDragImage->Show();
// Looking at method wxDragImage::UpdateBackingFromWindow
wxDC  * wxDragImageUpdateBackingFromWindowwindowDC0;
wxMemoryDC  * wxDragImageUpdateBackingFromWindowdestDC1;
wxRect  * wxDragImageUpdateBackingFromWindowsourceRect2;
wxRect  * wxDragImageUpdateBackingFromWindowdestRect3;
bool retwxDragImageUpdateBackingFromWindow0 = mywxDragImage->UpdateBackingFromWindow( * wxDragImageUpdateBackingFromWindowwindowDC0,  * wxDragImageUpdateBackingFromWindowdestDC1,  * wxDragImageUpdateBackingFromWindowsourceRect2,  * wxDragImageUpdateBackingFromWindowdestRect3);

// Looking at class wxDropFilesEvent
wxDropFilesEvent * mywxDropFilesEvent;
// Looking at method wxDropFilesEvent::wxDropFilesEvent
WXTYPE  * wxDropFilesEventwxDropFilesEventid0;
int  * wxDropFilesEventwxDropFilesEventnoFiles1;
wxString*  * wxDropFilesEventwxDropFilesEventfiles2;
wxDropFilesEvent * newwxDropFilesEvent0 = new wxDropFilesEvent( * wxDropFilesEventwxDropFilesEventid0,  * wxDropFilesEventwxDropFilesEventnoFiles1,  * wxDropFilesEventwxDropFilesEventfiles2);
// Looking at method wxDropFilesEvent::m_files
// Looking at method wxDropFilesEvent::m_noFiles
// Looking at method wxDropFilesEvent::m_pos
// Looking at method wxDropFilesEvent::GetFiles
wxString* retwxDropFilesEventGetFiles0 = mywxDropFilesEvent->GetFiles();
// Looking at method wxDropFilesEvent::GetNumberOfFiles
int retwxDropFilesEventGetNumberOfFiles0 = mywxDropFilesEvent->GetNumberOfFiles();
// Looking at method wxDropFilesEvent::GetPosition
wxPoint retwxDropFilesEventGetPosition0 = mywxDropFilesEvent->GetPosition();

// Looking at class wxDropSource
wxDropSource * mywxDropSource;
// Looking at method wxDropSource::wxDropSource
wxWindow*  * wxDropSourcewxDropSourcewin0;
wxIconOrCursor  * wxDropSourcewxDropSourceiconCopy1;
wxIconOrCursor  * wxDropSourcewxDropSourceiconMove2;
wxIconOrCursor  * wxDropSourcewxDropSourceiconNone3;
wxDropSource * newwxDropSource0 = new wxDropSource( * wxDropSourcewxDropSourcewin0,  * wxDropSourcewxDropSourceiconCopy1,  * wxDropSourcewxDropSourceiconMove2,  * wxDropSourcewxDropSourceiconNone3);
wxDataObject  * wxDropSourcewxDropSourcedata4;
wxWindow*  * wxDropSourcewxDropSourcewin5;
wxIconOrCursor  * wxDropSourcewxDropSourceiconCopy6;
wxIconOrCursor  * wxDropSourcewxDropSourceiconMove7;
wxIconOrCursor  * wxDropSourcewxDropSourceiconNone8;
wxDropSource * newwxDropSource1 = new wxDropSource( * wxDropSourcewxDropSourcedata4,  * wxDropSourcewxDropSourcewin5,  * wxDropSourcewxDropSourceiconCopy6,  * wxDropSourcewxDropSourceiconMove7,  * wxDropSourcewxDropSourceiconNone8);
// Looking at method wxDropSource::SetData
wxDataObject  * wxDropSourceSetDatadata0;
mywxDropSource->SetData( * wxDropSourceSetDatadata0);
// Looking at method wxDropSource::DoDragDrop
// Looking at method wxDropSource::GetDataObject
wxDataObject * retwxDropSourceGetDataObject0 = mywxDropSource->GetDataObject();
// Looking at method wxDropSource::GiveFeedback
// Looking at method wxDropSource::SetCursor
wxDragResult  * wxDropSourceSetCursorres0;
wxCursor  * wxDropSourceSetCursorcursor1;
mywxDropSource->SetCursor( * wxDropSourceSetCursorres0,  * wxDropSourceSetCursorcursor1);

// Looking at class wxDropTarget
wxDropTarget * mywxDropTarget;
// Looking at method wxDropTarget::wxDropTarget
wxDataObject*  * wxDropTargetwxDropTargetdata0;
wxDropTarget * newwxDropTarget0 = new wxDropTarget( * wxDropTargetwxDropTargetdata0);
// Looking at method wxDropTarget::GetData
// Looking at method wxDropTarget::OnData
// Looking at method wxDropTarget::OnDrop
// Looking at method wxDropTarget::OnEnter
// Looking at method wxDropTarget::OnDragOver
// Looking at method wxDropTarget::OnLeave
// Looking at method wxDropTarget::SetDataObject
wxDataObject*  * wxDropTargetSetDataObjectdata0;
mywxDropTarget->SetDataObject( * wxDropTargetSetDataObjectdata0);

// Looking at class wxDynamicLibrary
wxDynamicLibrary * mywxDynamicLibrary;
// Looking at method wxDynamicLibrary::wxDynamicLibrary
wxDynamicLibrary * newwxDynamicLibrary0 = new wxDynamicLibrary();
wxString  * wxDynamicLibrarywxDynamicLibraryname0;
int  * wxDynamicLibrarywxDynamicLibraryflags1;
wxDynamicLibrary * newwxDynamicLibrary1 = new wxDynamicLibrary( * wxDynamicLibrarywxDynamicLibraryname0,  * wxDynamicLibrarywxDynamicLibraryflags1);
// Looking at method wxDynamicLibrary::CanonicalizeName
wxString  * wxDynamicLibraryCanonicalizeNamename0;
wxDynamicLibraryCategory  * wxDynamicLibraryCanonicalizeNamecat1;
wxString retwxDynamicLibraryCanonicalizeName0 = mywxDynamicLibrary->CanonicalizeName( * wxDynamicLibraryCanonicalizeNamename0,  * wxDynamicLibraryCanonicalizeNamecat1);
// Looking at method wxDynamicLibrary::CanonicalizePluginName
wxString  * wxDynamicLibraryCanonicalizePluginNamename0;
wxPluginCategory  * wxDynamicLibraryCanonicalizePluginNamecat1;
wxString retwxDynamicLibraryCanonicalizePluginName0 = mywxDynamicLibrary->CanonicalizePluginName( * wxDynamicLibraryCanonicalizePluginNamename0,  * wxDynamicLibraryCanonicalizePluginNamecat1);
// Looking at method wxDynamicLibrary::Detach
wxDllType retwxDynamicLibraryDetach0 = mywxDynamicLibrary->Detach();
// Looking at method wxDynamicLibrary::GetSymbol
wxString  * wxDynamicLibraryGetSymbolname0;
mywxDynamicLibrary->GetSymbol( * wxDynamicLibraryGetSymbolname0);
// Looking at method wxDynamicLibrary::HasSymbol
wxString  * wxDynamicLibraryHasSymbolname0;
bool retwxDynamicLibraryHasSymbol0 = mywxDynamicLibrary->HasSymbol( * wxDynamicLibraryHasSymbolname0);
// Looking at method wxDynamicLibrary::IsLoaded
bool retwxDynamicLibraryIsLoaded0 = mywxDynamicLibrary->IsLoaded();
// Looking at method wxDynamicLibrary::ListLoaded
static wxDynamicLibraryDetailsArray retwxDynamicLibraryListLoaded0 = mywxDynamicLibrary->ListLoaded();
// Looking at method wxDynamicLibrary::Load
wxString  * wxDynamicLibraryLoadname0;
int  * wxDynamicLibraryLoadflags1;
bool retwxDynamicLibraryLoad0 = mywxDynamicLibrary->Load( * wxDynamicLibraryLoadname0,  * wxDynamicLibraryLoadflags1);
// Looking at method wxDynamicLibrary::Unload
mywxDynamicLibrary->Unload();
wxDllType  * wxDynamicLibraryUnloadhandle0;
mywxDynamicLibrary->Unload( * wxDynamicLibraryUnloadhandle0);

// Looking at class wxDynamicLibraryDetails
wxDynamicLibraryDetails * mywxDynamicLibraryDetails;
// Looking at method wxDynamicLibraryDetails::GetName
wxString retwxDynamicLibraryDetailsGetName0 = mywxDynamicLibraryDetails->GetName();
// Looking at method wxDynamicLibraryDetails::GetPath
wxString retwxDynamicLibraryDetailsGetPath0 = mywxDynamicLibraryDetails->GetPath();
// Looking at method wxDynamicLibraryDetails::GetAddress
void ** * wxDynamicLibraryDetailsGetAddressaddr0;
size_t * * wxDynamicLibraryDetailsGetAddresslen1;
bool retwxDynamicLibraryDetailsGetAddress0 = mywxDynamicLibraryDetails->GetAddress( * wxDynamicLibraryDetailsGetAddressaddr0,  * wxDynamicLibraryDetailsGetAddresslen1);
// Looking at method wxDynamicLibraryDetails::GetVersion
wxString retwxDynamicLibraryDetailsGetVersion0 = mywxDynamicLibraryDetails->GetVersion();

// Looking at class wxEncodingConverter
wxEncodingConverter * mywxEncodingConverter;
// Looking at method wxEncodingConverter::wxEncodingConverter
wxEncodingConverter * newwxEncodingConverter0 = new wxEncodingConverter();
// Looking at method wxEncodingConverter::Init
wxFontEncoding  * wxEncodingConverterInitinput_enc0;
wxFontEncoding  * wxEncodingConverterInitoutput_enc1;
int  * wxEncodingConverterInitmethod2;
bool retwxEncodingConverterInit0 = mywxEncodingConverter->Init( * wxEncodingConverterInitinput_enc0,  * wxEncodingConverterInitoutput_enc1,  * wxEncodingConverterInitmethod2);
// Looking at method wxEncodingConverter::CanConvert
wxFontEncoding * wxEncodingConverterCanConvertencIn0;
wxFontEncoding  * wxEncodingConverterCanConvertencOut1;
static bool retwxEncodingConverterCanConvert0 = mywxEncodingConverter->CanConvert( * wxEncodingConverterCanConvertencIn0,  * wxEncodingConverterCanConvertencOut1);
// Looking at method wxEncodingConverter::Convert
char*  * wxEncodingConverterConvertinput0;
char*  * wxEncodingConverterConvertoutput1;
bool retwxEncodingConverterConvert0 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertinput0,  * wxEncodingConverterConvertoutput1);
wchar_t*  * wxEncodingConverterConvertinput2;
wchar_t*  * wxEncodingConverterConvertoutput3;
bool retwxEncodingConverterConvert1 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertinput2,  * wxEncodingConverterConvertoutput3);
char*  * wxEncodingConverterConvertinput4;
wchar_t*  * wxEncodingConverterConvertoutput5;
bool retwxEncodingConverterConvert2 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertinput4,  * wxEncodingConverterConvertoutput5);
wchar_t*  * wxEncodingConverterConvertinput6;
char*  * wxEncodingConverterConvertoutput7;
bool retwxEncodingConverterConvert3 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertinput6,  * wxEncodingConverterConvertoutput7);
char*  * wxEncodingConverterConvertstr8;
bool retwxEncodingConverterConvert4 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertstr8);
wchar_t*  * wxEncodingConverterConvertstr9;
bool retwxEncodingConverterConvert5 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertstr9);
wxString  * wxEncodingConverterConvertinput10;
wxString retwxEncodingConverterConvert6 = mywxEncodingConverter->Convert( * wxEncodingConverterConvertinput10);
// Looking at method wxEncodingConverter::GetPlatformEquivalents
wxFontEncoding  * wxEncodingConverterGetPlatformEquivalentsenc0;
int  * wxEncodingConverterGetPlatformEquivalentsplatform1;
static wxFontEncodingArray retwxEncodingConverterGetPlatformEquivalents0 = mywxEncodingConverter->GetPlatformEquivalents( * wxEncodingConverterGetPlatformEquivalentsenc0,  * wxEncodingConverterGetPlatformEquivalentsplatform1);
// Looking at method wxEncodingConverter::GetAllEquivalents
wxFontEncoding  * wxEncodingConverterGetAllEquivalentsenc0;
static wxFontEncodingArray retwxEncodingConverterGetAllEquivalents0 = mywxEncodingConverter->GetAllEquivalents( * wxEncodingConverterGetAllEquivalentsenc0);

// Looking at class wxEraseEvent
wxEraseEvent * mywxEraseEvent;
// Looking at method wxEraseEvent::wxEraseEvent
int  * wxEraseEventwxEraseEventid0;
wxDC*  * wxEraseEventwxEraseEventdc1;
wxEraseEvent * newwxEraseEvent0 = new wxEraseEvent( * wxEraseEventwxEraseEventid0,  * wxEraseEventwxEraseEventdc1);
// Looking at method wxEraseEvent::GetDC
wxDC* retwxEraseEventGetDC0 = mywxEraseEvent->GetDC();

// Looking at class wxEvtHandler
wxEvtHandler * mywxEvtHandler;
// Looking at method wxEvtHandler::wxEvtHandler
wxEvtHandler * newwxEvtHandler0 = new wxEvtHandler();
// Looking at method wxEvtHandler::AddPendingEvent
wxEvent  * wxEvtHandlerAddPendingEventevent0;
mywxEvtHandler->AddPendingEvent( * wxEvtHandlerAddPendingEventevent0);
// Looking at method wxEvtHandler::Connect
int  * wxEvtHandlerConnectid0;
int  * wxEvtHandlerConnectlastId1;
wxEventType  * wxEvtHandlerConnecteventType2;
wxObjectEventFunction  * wxEvtHandlerConnectfunction3;
wxObject*  * wxEvtHandlerConnectuserData4;
wxEvtHandler*  * wxEvtHandlerConnecteventSink5;
mywxEvtHandler->Connect( * wxEvtHandlerConnectid0,  * wxEvtHandlerConnectlastId1,  * wxEvtHandlerConnecteventType2,  * wxEvtHandlerConnectfunction3,  * wxEvtHandlerConnectuserData4,  * wxEvtHandlerConnecteventSink5);
int  * wxEvtHandlerConnectid6;
wxEventType  * wxEvtHandlerConnecteventType7;
wxObjectEventFunction  * wxEvtHandlerConnectfunction8;
wxObject*  * wxEvtHandlerConnectuserData9;
wxEvtHandler*  * wxEvtHandlerConnecteventSink10;
mywxEvtHandler->Connect( * wxEvtHandlerConnectid6,  * wxEvtHandlerConnecteventType7,  * wxEvtHandlerConnectfunction8,  * wxEvtHandlerConnectuserData9,  * wxEvtHandlerConnecteventSink10);
wxEventType  * wxEvtHandlerConnecteventType11;
wxObjectEventFunction  * wxEvtHandlerConnectfunction12;
wxObject*  * wxEvtHandlerConnectuserData13;
wxEvtHandler*  * wxEvtHandlerConnecteventSink14;
mywxEvtHandler->Connect( * wxEvtHandlerConnecteventType11,  * wxEvtHandlerConnectfunction12,  * wxEvtHandlerConnectuserData13,  * wxEvtHandlerConnecteventSink14);
// Looking at method wxEvtHandler::Disconnect
int  * wxEvtHandlerDisconnectid0;
wxEventType  * wxEvtHandlerDisconnecteventType1;
wxObjectEventFunction  * wxEvtHandlerDisconnectfunction2;
wxObject*  * wxEvtHandlerDisconnectuserData3;
wxEvtHandler*  * wxEvtHandlerDisconnecteventSink4;
bool retwxEvtHandlerDisconnect0 = mywxEvtHandler->Disconnect( * wxEvtHandlerDisconnectid0,  * wxEvtHandlerDisconnecteventType1,  * wxEvtHandlerDisconnectfunction2,  * wxEvtHandlerDisconnectuserData3,  * wxEvtHandlerDisconnecteventSink4);
int  * wxEvtHandlerDisconnectid5;
int  * wxEvtHandlerDisconnectlastId6;
wxEventType  * wxEvtHandlerDisconnecteventType7;
wxObjectEventFunction  * wxEvtHandlerDisconnectfunction8;
wxObject*  * wxEvtHandlerDisconnectuserData9;
wxEvtHandler*  * wxEvtHandlerDisconnecteventSink10;
bool retwxEvtHandlerDisconnect1 = mywxEvtHandler->Disconnect( * wxEvtHandlerDisconnectid5,  * wxEvtHandlerDisconnectlastId6,  * wxEvtHandlerDisconnecteventType7,  * wxEvtHandlerDisconnectfunction8,  * wxEvtHandlerDisconnectuserData9,  * wxEvtHandlerDisconnecteventSink10);
// Looking at method wxEvtHandler::GetClientData
mywxEvtHandler->GetClientData();
// Looking at method wxEvtHandler::GetClientObject
wxClientData* retwxEvtHandlerGetClientObject0 = mywxEvtHandler->GetClientObject();
// Looking at method wxEvtHandler::GetEvtHandlerEnabled
bool retwxEvtHandlerGetEvtHandlerEnabled0 = mywxEvtHandler->GetEvtHandlerEnabled();
// Looking at method wxEvtHandler::GetNextHandler
wxEvtHandler* retwxEvtHandlerGetNextHandler0 = mywxEvtHandler->GetNextHandler();
// Looking at method wxEvtHandler::GetPreviousHandler
wxEvtHandler* retwxEvtHandlerGetPreviousHandler0 = mywxEvtHandler->GetPreviousHandler();
// Looking at method wxEvtHandler::ProcessEvent
// Looking at method wxEvtHandler::SearchEventTable
// Looking at method wxEvtHandler::SetClientData
void*  * wxEvtHandlerSetClientDatadata0;
mywxEvtHandler->SetClientData( * wxEvtHandlerSetClientDatadata0);
// Looking at method wxEvtHandler::SetClientObject
wxClientData*  * wxEvtHandlerSetClientObjectdata0;
mywxEvtHandler->SetClientObject( * wxEvtHandlerSetClientObjectdata0);
// Looking at method wxEvtHandler::SetEvtHandlerEnabled
bool  * wxEvtHandlerSetEvtHandlerEnabledenabled0;
mywxEvtHandler->SetEvtHandlerEnabled( * wxEvtHandlerSetEvtHandlerEnabledenabled0);
// Looking at method wxEvtHandler::SetNextHandler
wxEvtHandler*  * wxEvtHandlerSetNextHandlerhandler0;
mywxEvtHandler->SetNextHandler( * wxEvtHandlerSetNextHandlerhandler0);
// Looking at method wxEvtHandler::SetPreviousHandler
wxEvtHandler*  * wxEvtHandlerSetPreviousHandlerhandler0;
mywxEvtHandler->SetPreviousHandler( * wxEvtHandlerSetPreviousHandlerhandler0);

// Looking at class wxFFile
wxFFile * mywxFFile;
// Looking at method wxFFile::wxFFile
wxFFile * newwxFFile0 = new wxFFile();
char*  * wxFFilewxFFilefilename0;
char*  * wxFFilewxFFilemode1;
wxFFile * newwxFFile1 = new wxFFile( * wxFFilewxFFilefilename0,  * wxFFilewxFFilemode1);
FILE*  * wxFFilewxFFilefp2;
wxFFile * newwxFFile2 = new wxFFile( * wxFFilewxFFilefp2);
// Looking at method wxFFile::Attach
FILE*  * wxFFileAttachfp0;
mywxFFile->Attach( * wxFFileAttachfp0);
// Looking at method wxFFile::Close
bool retwxFFileClose0 = mywxFFile->Close();
// Looking at method wxFFile::Detach
mywxFFile->Detach();
// Looking at method wxFFile::fp
FILE * retwxFFilefp0 = mywxFFile->fp();
// Looking at method wxFFile::Eof
bool retwxFFileEof0 = mywxFFile->Eof();
// Looking at method wxFFile::Error
// Looking at method wxFFile::Flush
bool retwxFFileFlush0 = mywxFFile->Flush();
// Looking at method wxFFile::GetKind
wxFileKind retwxFFileGetKind0 = mywxFFile->GetKind();
// Looking at method wxFFile::IsOpened
bool retwxFFileIsOpened0 = mywxFFile->IsOpened();
// Looking at method wxFFile::Length
wxFileOffset retwxFFileLength0 = mywxFFile->Length();
// Looking at method wxFFile::Open
char*  * wxFFileOpenfilename0;
char*  * wxFFileOpenmode1;
bool retwxFFileOpen0 = mywxFFile->Open( * wxFFileOpenfilename0,  * wxFFileOpenmode1);
// Looking at method wxFFile::Read
void*  * wxFFileReadbuffer0;
size_t  * wxFFileReadcount1;
size_t retwxFFileRead0 = mywxFFile->Read( * wxFFileReadbuffer0,  * wxFFileReadcount1);
// Looking at method wxFFile::ReadAll
wxString *  * wxFFileReadAllstr0;
wxMBConv  * wxFFileReadAllconv1;
bool retwxFFileReadAll0 = mywxFFile->ReadAll( * wxFFileReadAllstr0,  * wxFFileReadAllconv1);
// Looking at method wxFFile::Seek
wxFileOffset  * wxFFileSeekofs0;
wxSeekMode  * wxFFileSeekmode1;
bool retwxFFileSeek0 = mywxFFile->Seek( * wxFFileSeekofs0,  * wxFFileSeekmode1);
// Looking at method wxFFile::SeekEnd
wxFileOffset  * wxFFileSeekEndofs0;
bool retwxFFileSeekEnd0 = mywxFFile->SeekEnd( * wxFFileSeekEndofs0);
// Looking at method wxFFile::Tell
wxFileOffset retwxFFileTell0 = mywxFFile->Tell();
// Looking at method wxFFile::Write
void*  * wxFFileWritebuffer0;
size_t  * wxFFileWritecount1;
size_t retwxFFileWrite0 = mywxFFile->Write( * wxFFileWritebuffer0,  * wxFFileWritecount1);
wxString  * wxFFileWrites2;
wxMBConv  * wxFFileWriteconv3;
bool retwxFFileWrite1 = mywxFFile->Write( * wxFFileWrites2,  * wxFFileWriteconv3);

// Looking at class wxFFileInputStream
wxFFileInputStream * mywxFFileInputStream;
// Looking at method wxFFileInputStream::wxFFileInputStream
wxString  * wxFFileInputStreamwxFFileInputStreamfilename0;
wxChar *  * wxFFileInputStreamwxFFileInputStreammode1;
wxFFileInputStream * newwxFFileInputStream0 = new wxFFileInputStream( * wxFFileInputStreamwxFFileInputStreamfilename0,  * wxFFileInputStreamwxFFileInputStreammode1);
wxFFile  * wxFFileInputStreamwxFFileInputStreamfile2;
wxFFileInputStream * newwxFFileInputStream1 = new wxFFileInputStream( * wxFFileInputStreamwxFFileInputStreamfile2);
FILE *  * wxFFileInputStreamwxFFileInputStreamfp3;
wxFFileInputStream * newwxFFileInputStream2 = new wxFFileInputStream( * wxFFileInputStreamwxFFileInputStreamfp3);
// Looking at method wxFFileInputStream::Ok
bool retwxFFileInputStreamOk0 = mywxFFileInputStream->Ok();

// Looking at class wxFFileOutputStream
wxFFileOutputStream * mywxFFileOutputStream;
// Looking at method wxFFileOutputStream::wxFFileOutputStream
wxString  * wxFFileOutputStreamwxFFileOutputStreamfilename0;
wxChar *  * wxFFileOutputStreamwxFFileOutputStreammode1;
wxFFileOutputStream * newwxFFileOutputStream0 = new wxFFileOutputStream( * wxFFileOutputStreamwxFFileOutputStreamfilename0,  * wxFFileOutputStreamwxFFileOutputStreammode1);
wxFFile  * wxFFileOutputStreamwxFFileOutputStreamfile2;
wxFFileOutputStream * newwxFFileOutputStream1 = new wxFFileOutputStream( * wxFFileOutputStreamwxFFileOutputStreamfile2);
FILE *  * wxFFileOutputStreamwxFFileOutputStreamfp3;
wxFFileOutputStream * newwxFFileOutputStream2 = new wxFFileOutputStream( * wxFFileOutputStreamwxFFileOutputStreamfp3);
// Looking at method wxFFileOutputStream::Ok
bool retwxFFileOutputStreamOk0 = mywxFFileOutputStream->Ok();

// Looking at class wxFFileStream
wxFFileStream * mywxFFileStream;
// Looking at method wxFFileStream::wxFFileStream
wxString  * wxFFileStreamwxFFileStreamiofileName0;
wxFFileStream * newwxFFileStream0 = new wxFFileStream( * wxFFileStreamwxFFileStreamiofileName0);

// Looking at class wxFSFile
wxFSFile * mywxFSFile;
// Looking at method wxFSFile::wxFSFile
wxInputStream * * wxFSFilewxFSFilestream0;
wxString  * wxFSFilewxFSFileloc1;
wxString  * wxFSFilewxFSFilemimetype2;
wxString  * wxFSFilewxFSFileanchor3;
wxDateTime  * wxFSFilewxFSFilemodif4;
wxFSFile * newwxFSFile0 = new wxFSFile( * wxFSFilewxFSFilestream0,  * wxFSFilewxFSFileloc1,  * wxFSFilewxFSFilemimetype2,  * wxFSFilewxFSFileanchor3,  * wxFSFilewxFSFilemodif4);
// Looking at method wxFSFile::GetAnchor
const wxString retwxFSFileGetAnchor0 = mywxFSFile->GetAnchor();
// Looking at method wxFSFile::GetLocation
const wxString retwxFSFileGetLocation0 = mywxFSFile->GetLocation();
// Looking at method wxFSFile::GetMimeType
const wxString retwxFSFileGetMimeType0 = mywxFSFile->GetMimeType();
// Looking at method wxFSFile::GetModificationTime
wxDateTime retwxFSFileGetModificationTime0 = mywxFSFile->GetModificationTime();
// Looking at method wxFSFile::GetStream
wxInputStream* retwxFSFileGetStream0 = mywxFSFile->GetStream();

// Looking at class wxFTP
wxFTP * mywxFTP;
// Looking at method wxFTP::wxFTP
wxFTP * newwxFTP0 = new wxFTP();
// Looking at method wxFTP::Abort
bool retwxFTPAbort0 = mywxFTP->Abort();
// Looking at method wxFTP::CheckCommand
wxString  * wxFTPCheckCommandcommand0;
char  * wxFTPCheckCommandret1;
bool retwxFTPCheckCommand0 = mywxFTP->CheckCommand( * wxFTPCheckCommandcommand0,  * wxFTPCheckCommandret1);
// Looking at method wxFTP::SendCommand
wxString  * wxFTPSendCommandcommand0;
char retwxFTPSendCommand0 = mywxFTP->SendCommand( * wxFTPSendCommandcommand0);
// Looking at method wxFTP::GetLastResult
const wxString retwxFTPGetLastResult0 = mywxFTP->GetLastResult();
// Looking at method wxFTP::ChDir
wxString  * wxFTPChDirdir0;
bool retwxFTPChDir0 = mywxFTP->ChDir( * wxFTPChDirdir0);
// Looking at method wxFTP::MkDir
wxString  * wxFTPMkDirdir0;
bool retwxFTPMkDir0 = mywxFTP->MkDir( * wxFTPMkDirdir0);
// Looking at method wxFTP::RmDir
wxString  * wxFTPRmDirdir0;
bool retwxFTPRmDir0 = mywxFTP->RmDir( * wxFTPRmDirdir0);
// Looking at method wxFTP::Pwd
wxString retwxFTPPwd0 = mywxFTP->Pwd();
// Looking at method wxFTP::Rename
wxString  * wxFTPRenamesrc0;
wxString  * wxFTPRenamedst1;
bool retwxFTPRename0 = mywxFTP->Rename( * wxFTPRenamesrc0,  * wxFTPRenamedst1);
// Looking at method wxFTP::RmFile
wxString  * wxFTPRmFilepath0;
bool retwxFTPRmFile0 = mywxFTP->RmFile( * wxFTPRmFilepath0);
// Looking at method wxFTP::SetAscii
bool retwxFTPSetAscii0 = mywxFTP->SetAscii();
// Looking at method wxFTP::SetBinary
bool retwxFTPSetBinary0 = mywxFTP->SetBinary();
// Looking at method wxFTP::SetPassive
bool  * wxFTPSetPassivepasv0;
mywxFTP->SetPassive( * wxFTPSetPassivepasv0);
// Looking at method wxFTP::SetTransferMode
TransferMode  * wxFTPSetTransferModemode0;
bool retwxFTPSetTransferMode0 = mywxFTP->SetTransferMode( * wxFTPSetTransferModemode0);
// Looking at method wxFTP::SetUser
wxString  * wxFTPSetUseruser0;
mywxFTP->SetUser( * wxFTPSetUseruser0);
// Looking at method wxFTP::SetPassword
wxString  * wxFTPSetPasswordpasswd0;
mywxFTP->SetPassword( * wxFTPSetPasswordpasswd0);
// Looking at method wxFTP::FileExists
wxString  * wxFTPFileExistsfilename0;
bool retwxFTPFileExists0 = mywxFTP->FileExists( * wxFTPFileExistsfilename0);
// Looking at method wxFTP::GetFileSize
wxString  * wxFTPGetFileSizefilename0;
int retwxFTPGetFileSize0 = mywxFTP->GetFileSize( * wxFTPGetFileSizefilename0);
// Looking at method wxFTP::GetDirList
wxArrayString  * wxFTPGetDirListfiles0;
wxString  * wxFTPGetDirListwildcard1;
bool retwxFTPGetDirList0 = mywxFTP->GetDirList( * wxFTPGetDirListfiles0,  * wxFTPGetDirListwildcard1);
// Looking at method wxFTP::GetFilesList
wxArrayString  * wxFTPGetFilesListfiles0;
wxString  * wxFTPGetFilesListwildcard1;
bool retwxFTPGetFilesList0 = mywxFTP->GetFilesList( * wxFTPGetFilesListfiles0,  * wxFTPGetFilesListwildcard1);
// Looking at method wxFTP::GetOutputStream
wxString  * wxFTPGetOutputStreamfile0;
wxOutputStream * retwxFTPGetOutputStream0 = mywxFTP->GetOutputStream( * wxFTPGetOutputStreamfile0);
// Looking at method wxFTP::GetInputStream
wxString  * wxFTPGetInputStreampath0;
wxInputStream * retwxFTPGetInputStream0 = mywxFTP->GetInputStream( * wxFTPGetInputStreampath0);

// Looking at class wxFile
wxFile * mywxFile;
// Looking at method wxFile::wxFile
wxFile * newwxFile0 = new wxFile();
char*  * wxFilewxFilefilename0;
wxFile::OpenMode  * wxFilewxFilemode1;
wxFile * newwxFile1 = new wxFile( * wxFilewxFilefilename0,  * wxFilewxFilemode1);
int  * wxFilewxFilefd2;
wxFile * newwxFile2 = new wxFile( * wxFilewxFilefd2);
// Looking at method wxFile::Access
char *  * wxFileAccessname0;
OpenMode  * wxFileAccessmode1;
static bool retwxFileAccess0 = mywxFile->Access( * wxFileAccessname0,  * wxFileAccessmode1);
// Looking at method wxFile::Attach
int  * wxFileAttachfd0;
mywxFile->Attach( * wxFileAttachfd0);
// Looking at method wxFile::Close
mywxFile->Close();
// Looking at method wxFile::Create
char*  * wxFileCreatefilename0;
bool  * wxFileCreateoverwrite1;
int  * wxFileCreateaccess2;
bool retwxFileCreate0 = mywxFile->Create( * wxFileCreatefilename0,  * wxFileCreateoverwrite1,  * wxFileCreateaccess2);
// Looking at method wxFile::Detach
mywxFile->Detach();
// Looking at method wxFile::fd
int retwxFilefd0 = mywxFile->fd();
// Looking at method wxFile::Eof
bool retwxFileEof0 = mywxFile->Eof();
// Looking at method wxFile::Exists
char*  * wxFileExistsfilename0;
static bool retwxFileExists0 = mywxFile->Exists( * wxFileExistsfilename0);
// Looking at method wxFile::Flush
bool retwxFileFlush0 = mywxFile->Flush();
// Looking at method wxFile::GetKind
wxFileKind retwxFileGetKind0 = mywxFile->GetKind();
// Looking at method wxFile::IsOpened
bool retwxFileIsOpened0 = mywxFile->IsOpened();
// Looking at method wxFile::Length
wxFileOffset retwxFileLength0 = mywxFile->Length();
// Looking at method wxFile::Open
char*  * wxFileOpenfilename0;
wxFile::OpenMode  * wxFileOpenmode1;
bool retwxFileOpen0 = mywxFile->Open( * wxFileOpenfilename0,  * wxFileOpenmode1);
// Looking at method wxFile::Read
void*  * wxFileReadbuffer0;
size_t  * wxFileReadcount1;
size_t retwxFileRead0 = mywxFile->Read( * wxFileReadbuffer0,  * wxFileReadcount1);
// Looking at method wxFile::Seek
wxFileOffset  * wxFileSeekofs0;
wxSeekMode  * wxFileSeekmode1;
wxFileOffset retwxFileSeek0 = mywxFile->Seek( * wxFileSeekofs0,  * wxFileSeekmode1);
// Looking at method wxFile::SeekEnd
wxFileOffset  * wxFileSeekEndofs0;
wxFileOffset retwxFileSeekEnd0 = mywxFile->SeekEnd( * wxFileSeekEndofs0);
// Looking at method wxFile::Tell
wxFileOffset retwxFileTell0 = mywxFile->Tell();
// Looking at method wxFile::Write
void*  * wxFileWritebuffer0;
wxFileOffset  * wxFileWritecount1;
size_t retwxFileWrite0 = mywxFile->Write( * wxFileWritebuffer0,  * wxFileWritecount1);
wxString  * wxFileWrites2;
wxMBConv  * wxFileWriteconv3;
bool retwxFileWrite1 = mywxFile->Write( * wxFileWrites2,  * wxFileWriteconv3);

// Looking at class wxFileConfig
wxFileConfig * mywxFileConfig;
// Looking at method wxFileConfig::wxFileConfig
wxInputStream  * wxFileConfigwxFileConfigis0;
wxMBConv  * wxFileConfigwxFileConfigconv1;
wxFileConfig * newwxFileConfig0 = new wxFileConfig( * wxFileConfigwxFileConfigis0,  * wxFileConfigwxFileConfigconv1);
// Looking at method wxFileConfig::Save
wxOutputStream  * wxFileConfigSaveos0;
wxMBConv  * wxFileConfigSaveconv1;
bool retwxFileConfigSave0 = mywxFileConfig->Save( * wxFileConfigSaveos0,  * wxFileConfigSaveconv1);
// Looking at method wxFileConfig::SetUmask
int  * wxFileConfigSetUmaskmode0;
mywxFileConfig->SetUmask( * wxFileConfigSetUmaskmode0);

// Looking at class wxFileDataObject
wxFileDataObject * mywxFileDataObject;
// Looking at method wxFileDataObject::
// Looking at method wxFileDataObject::AddFile
// Looking at method wxFileDataObject::GetFilenames
const wxArrayString  retwxFileDataObjectGetFilenames0 = mywxFileDataObject->GetFilenames();

// Looking at class wxFileDialog
wxFileDialog * mywxFileDialog;
// Looking at method wxFileDialog::wxFileDialog
wxWindow*  * wxFileDialogwxFileDialogparent0;
wxString  * wxFileDialogwxFileDialogmessage1;
wxString  * wxFileDialogwxFileDialogdefaultDir2;
wxString  * wxFileDialogwxFileDialogdefaultFile3;
wxString  * wxFileDialogwxFileDialogwildcard4;
long  * wxFileDialogwxFileDialogstyle5;
wxPoint  * wxFileDialogwxFileDialogpos6;
wxFileDialog * newwxFileDialog0 = new wxFileDialog( * wxFileDialogwxFileDialogparent0,  * wxFileDialogwxFileDialogmessage1,  * wxFileDialogwxFileDialogdefaultDir2,  * wxFileDialogwxFileDialogdefaultFile3,  * wxFileDialogwxFileDialogwildcard4,  * wxFileDialogwxFileDialogstyle5,  * wxFileDialogwxFileDialogpos6);
// Looking at method wxFileDialog::GetDirectory
wxString retwxFileDialogGetDirectory0 = mywxFileDialog->GetDirectory();
// Looking at method wxFileDialog::GetFilename
wxString retwxFileDialogGetFilename0 = mywxFileDialog->GetFilename();
// Looking at method wxFileDialog::GetFilenames
wxArrayString  * wxFileDialogGetFilenamesfilenames0;
mywxFileDialog->GetFilenames( * wxFileDialogGetFilenamesfilenames0);
// Looking at method wxFileDialog::GetFilterIndex
int retwxFileDialogGetFilterIndex0 = mywxFileDialog->GetFilterIndex();
// Looking at method wxFileDialog::GetMessage
wxString retwxFileDialogGetMessage0 = mywxFileDialog->GetMessage();
// Looking at method wxFileDialog::GetPath
wxString retwxFileDialogGetPath0 = mywxFileDialog->GetPath();
// Looking at method wxFileDialog::GetPaths
wxArrayString  * wxFileDialogGetPathspaths0;
mywxFileDialog->GetPaths( * wxFileDialogGetPathspaths0);
// Looking at method wxFileDialog::GetStyle
long retwxFileDialogGetStyle0 = mywxFileDialog->GetStyle();
// Looking at method wxFileDialog::GetWildcard
wxString retwxFileDialogGetWildcard0 = mywxFileDialog->GetWildcard();
// Looking at method wxFileDialog::SetDirectory
wxString  * wxFileDialogSetDirectorydirectory0;
mywxFileDialog->SetDirectory( * wxFileDialogSetDirectorydirectory0);
// Looking at method wxFileDialog::SetFilename
wxString  * wxFileDialogSetFilenamesetfilename0;
mywxFileDialog->SetFilename( * wxFileDialogSetFilenamesetfilename0);
// Looking at method wxFileDialog::SetFilterIndex
int  * wxFileDialogSetFilterIndexfilterIndex0;
mywxFileDialog->SetFilterIndex( * wxFileDialogSetFilterIndexfilterIndex0);
// Looking at method wxFileDialog::SetMessage
wxString  * wxFileDialogSetMessagemessage0;
mywxFileDialog->SetMessage( * wxFileDialogSetMessagemessage0);
// Looking at method wxFileDialog::SetPath
wxString  * wxFileDialogSetPathpath0;
mywxFileDialog->SetPath( * wxFileDialogSetPathpath0);
// Looking at method wxFileDialog::SetStyle
long  * wxFileDialogSetStylestyle0;
mywxFileDialog->SetStyle( * wxFileDialogSetStylestyle0);
// Looking at method wxFileDialog::SetWildcard
wxString  * wxFileDialogSetWildcardwildCard0;
mywxFileDialog->SetWildcard( * wxFileDialogSetWildcardwildCard0);
// Looking at method wxFileDialog::ShowModal
int retwxFileDialogShowModal0 = mywxFileDialog->ShowModal();

// Looking at class wxFileHistory
wxFileHistory * mywxFileHistory;
// Looking at method wxFileHistory::m_fileHistory
// Looking at method wxFileHistory::m_fileHistoryN
// Looking at method wxFileHistory::m_fileMaxFiles
// Looking at method wxFileHistory::m_fileMenu
// Looking at method wxFileHistory::wxFileHistory
size_t  * wxFileHistorywxFileHistorymaxFiles0;
wxWindowID  * wxFileHistorywxFileHistoryidBase1;
wxFileHistory * newwxFileHistory0 = new wxFileHistory( * wxFileHistorywxFileHistorymaxFiles0,  * wxFileHistorywxFileHistoryidBase1);
// Looking at method wxFileHistory::AddFileToHistory
wxString  * wxFileHistoryAddFileToHistoryfilename0;
mywxFileHistory->AddFileToHistory( * wxFileHistoryAddFileToHistoryfilename0);
// Looking at method wxFileHistory::AddFilesToMenu
mywxFileHistory->AddFilesToMenu();
wxMenu*  * wxFileHistoryAddFilesToMenumenu0;
mywxFileHistory->AddFilesToMenu( * wxFileHistoryAddFilesToMenumenu0);
// Looking at method wxFileHistory::GetHistoryFile
size_t  * wxFileHistoryGetHistoryFileindex0;
wxString retwxFileHistoryGetHistoryFile0 = mywxFileHistory->GetHistoryFile( * wxFileHistoryGetHistoryFileindex0);
// Looking at method wxFileHistory::GetMaxFiles
size_t retwxFileHistoryGetMaxFiles0 = mywxFileHistory->GetMaxFiles();
// Looking at method wxFileHistory::GetCount
size_t retwxFileHistoryGetCount0 = mywxFileHistory->GetCount();
// Looking at method wxFileHistory::Load
wxConfigBase  * wxFileHistoryLoadconfig0;
mywxFileHistory->Load( * wxFileHistoryLoadconfig0);
// Looking at method wxFileHistory::RemoveMenu
wxMenu*  * wxFileHistoryRemoveMenumenu0;
mywxFileHistory->RemoveMenu( * wxFileHistoryRemoveMenumenu0);
// Looking at method wxFileHistory::Save
wxConfigBase  * wxFileHistorySaveconfig0;
mywxFileHistory->Save( * wxFileHistorySaveconfig0);
// Looking at method wxFileHistory::UseMenu
wxMenu*  * wxFileHistoryUseMenumenu0;
mywxFileHistory->UseMenu( * wxFileHistoryUseMenumenu0);

// Looking at class wxFileInputStream
wxFileInputStream * mywxFileInputStream;
// Looking at method wxFileInputStream::wxFileInputStream
wxString  * wxFileInputStreamwxFileInputStreamifileName0;
wxFileInputStream * newwxFileInputStream0 = new wxFileInputStream( * wxFileInputStreamwxFileInputStreamifileName0);
wxFile  * wxFileInputStreamwxFileInputStreamfile1;
wxFileInputStream * newwxFileInputStream1 = new wxFileInputStream( * wxFileInputStreamwxFileInputStreamfile1);
int  * wxFileInputStreamwxFileInputStreamfd2;
wxFileInputStream * newwxFileInputStream2 = new wxFileInputStream( * wxFileInputStreamwxFileInputStreamfd2);
// Looking at method wxFileInputStream::Ok
bool retwxFileInputStreamOk0 = mywxFileInputStream->Ok();

// Looking at class wxFileName
wxFileName * mywxFileName;
// Looking at method wxFileName::
// Looking at method wxFileName::
// Looking at method wxFileName::
// Looking at method wxFileName::
// Looking at method wxFileName::
// Looking at method wxFileName::wxFileName
wxFileName * newwxFileName0 = new wxFileName();
wxFileName  * wxFileNamewxFileNamefilename0;
wxFileName * newwxFileName1 = new wxFileName( * wxFileNamewxFileNamefilename0);
wxString  * wxFileNamewxFileNamefullpath1;
wxPathFormat  * wxFileNamewxFileNameformat2;
wxFileName * newwxFileName2 = new wxFileName( * wxFileNamewxFileNamefullpath1,  * wxFileNamewxFileNameformat2);
wxString  * wxFileNamewxFileNamepath3;
wxString  * wxFileNamewxFileNamename4;
wxPathFormat  * wxFileNamewxFileNameformat5;
wxFileName * newwxFileName3 = new wxFileName( * wxFileNamewxFileNamepath3,  * wxFileNamewxFileNamename4,  * wxFileNamewxFileNameformat5);
wxString  * wxFileNamewxFileNamepath6;
wxString  * wxFileNamewxFileNamename7;
wxString  * wxFileNamewxFileNameext8;
wxPathFormat  * wxFileNamewxFileNameformat9;
wxFileName * newwxFileName4 = new wxFileName( * wxFileNamewxFileNamepath6,  * wxFileNamewxFileNamename7,  * wxFileNamewxFileNameext8,  * wxFileNamewxFileNameformat9);
wxString  * wxFileNamewxFileNamevolume10;
wxString  * wxFileNamewxFileNamepath11;
wxString  * wxFileNamewxFileNamename12;
wxString  * wxFileNamewxFileNameext13;
wxPathFormat  * wxFileNamewxFileNameformat14;
wxFileName * newwxFileName5 = new wxFileName( * wxFileNamewxFileNamevolume10,  * wxFileNamewxFileNamepath11,  * wxFileNamewxFileNamename12,  * wxFileNamewxFileNameext13,  * wxFileNamewxFileNameformat14);
// Looking at method wxFileName::AppendDir
wxString  * wxFileNameAppendDirdir0;
mywxFileName->AppendDir( * wxFileNameAppendDirdir0);
// Looking at method wxFileName::Assign
wxFileName  * wxFileNameAssignfilepath0;
mywxFileName->Assign( * wxFileNameAssignfilepath0);
wxString  * wxFileNameAssignfullpath1;
wxPathFormat  * wxFileNameAssignformat2;
mywxFileName->Assign( * wxFileNameAssignfullpath1,  * wxFileNameAssignformat2);
wxString  * wxFileNameAssignvolume3;
wxString  * wxFileNameAssignpath4;
wxString  * wxFileNameAssignname5;
wxString  * wxFileNameAssignext6;
wxPathFormat  * wxFileNameAssignformat7;
mywxFileName->Assign( * wxFileNameAssignvolume3,  * wxFileNameAssignpath4,  * wxFileNameAssignname5,  * wxFileNameAssignext6,  * wxFileNameAssignformat7);
wxString  * wxFileNameAssignpath8;
wxString  * wxFileNameAssignname9;
wxPathFormat  * wxFileNameAssignformat10;
mywxFileName->Assign( * wxFileNameAssignpath8,  * wxFileNameAssignname9,  * wxFileNameAssignformat10);
wxString  * wxFileNameAssignpath11;
wxString  * wxFileNameAssignname12;
wxString  * wxFileNameAssignext13;
wxPathFormat  * wxFileNameAssignformat14;
mywxFileName->Assign( * wxFileNameAssignpath11,  * wxFileNameAssignname12,  * wxFileNameAssignext13,  * wxFileNameAssignformat14);
// Looking at method wxFileName::AssignCwd
wxString  * wxFileNameAssignCwdvolume0;
mywxFileName->AssignCwd( * wxFileNameAssignCwdvolume0);
// Looking at method wxFileName::AssignDir
wxString  * wxFileNameAssignDirdir0;
wxPathFormat  * wxFileNameAssignDirformat1;
mywxFileName->AssignDir( * wxFileNameAssignDirdir0,  * wxFileNameAssignDirformat1);
// Looking at method wxFileName::AssignHomeDir
mywxFileName->AssignHomeDir();
// Looking at method wxFileName::AssignTempFileName
wxString  * wxFileNameAssignTempFileNameprefix0;
wxFile * * wxFileNameAssignTempFileNamefileTemp1;
mywxFileName->AssignTempFileName( * wxFileNameAssignTempFileNameprefix0,  * wxFileNameAssignTempFileNamefileTemp1);
// Looking at method wxFileName::Clear
mywxFileName->Clear();
// Looking at method wxFileName::CreateTempFileName
wxString  * wxFileNameCreateTempFileNameprefix0;
wxFile * * wxFileNameCreateTempFileNamefileTemp1;
static wxString retwxFileNameCreateTempFileName0 = mywxFileName->CreateTempFileName( * wxFileNameCreateTempFileNameprefix0,  * wxFileNameCreateTempFileNamefileTemp1);
// Looking at method wxFileName::DirExists
bool retwxFileNameDirExists0 = mywxFileName->DirExists();
wxString  * wxFileNameDirExistsdir0;
static bool retwxFileNameDirExists1 = mywxFileName->DirExists( * wxFileNameDirExistsdir0);
// Looking at method wxFileName::DirName
wxString  * wxFileNameDirNamedir0;
wxPathFormat  * wxFileNameDirNameformat1;
static wxFileName retwxFileNameDirName0 = mywxFileName->DirName( * wxFileNameDirNamedir0,  * wxFileNameDirNameformat1);
// Looking at method wxFileName::FileExists
bool retwxFileNameFileExists0 = mywxFileName->FileExists();
wxString  * wxFileNameFileExistsfile0;
static bool retwxFileNameFileExists1 = mywxFileName->FileExists( * wxFileNameFileExistsfile0);
// Looking at method wxFileName::FileName
wxString  * wxFileNameFileNamefile0;
wxPathFormat  * wxFileNameFileNameformat1;
static wxFileName retwxFileNameFileName0 = mywxFileName->FileName( * wxFileNameFileNamefile0,  * wxFileNameFileNameformat1);
// Looking at method wxFileName::GetCwd
wxString  * wxFileNameGetCwdvolume0;
static wxString retwxFileNameGetCwd0 = mywxFileName->GetCwd( * wxFileNameGetCwdvolume0);
// Looking at method wxFileName::GetDirCount
size_t retwxFileNameGetDirCount0 = mywxFileName->GetDirCount();
// Looking at method wxFileName::GetDirs
const wxArrayString retwxFileNameGetDirs0 = mywxFileName->GetDirs();
// Looking at method wxFileName::GetExt
wxString retwxFileNameGetExt0 = mywxFileName->GetExt();
// Looking at method wxFileName::GetForbiddenChars
wxPathFormat  * wxFileNameGetForbiddenCharsformat0;
static wxString retwxFileNameGetForbiddenChars0 = mywxFileName->GetForbiddenChars( * wxFileNameGetForbiddenCharsformat0);
// Looking at method wxFileName::GetFormat
wxPathFormat  * wxFileNameGetFormatformat0;
static wxPathFormat retwxFileNameGetFormat0 = mywxFileName->GetFormat( * wxFileNameGetFormatformat0);
// Looking at method wxFileName::GetFullName
wxString retwxFileNameGetFullName0 = mywxFileName->GetFullName();
// Looking at method wxFileName::GetFullPath
wxPathFormat  * wxFileNameGetFullPathformat0;
wxString retwxFileNameGetFullPath0 = mywxFileName->GetFullPath( * wxFileNameGetFullPathformat0);
// Looking at method wxFileName::GetHomeDir
static wxString retwxFileNameGetHomeDir0 = mywxFileName->GetHomeDir();
// Looking at method wxFileName::GetLongPath
wxString retwxFileNameGetLongPath0 = mywxFileName->GetLongPath();
// Looking at method wxFileName::GetModificationTime
wxDateTime retwxFileNameGetModificationTime0 = mywxFileName->GetModificationTime();
// Looking at method wxFileName::GetName
wxString retwxFileNameGetName0 = mywxFileName->GetName();
// Looking at method wxFileName::GetPath
int  * wxFileNameGetPathflags0;
wxPathFormat  * wxFileNameGetPathformat1;
wxString retwxFileNameGetPath0 = mywxFileName->GetPath( * wxFileNameGetPathflags0,  * wxFileNameGetPathformat1);
// Looking at method wxFileName::GetPathSeparator
wxPathFormat  * wxFileNameGetPathSeparatorformat0;
static wxChar retwxFileNameGetPathSeparator0 = mywxFileName->GetPathSeparator( * wxFileNameGetPathSeparatorformat0);
// Looking at method wxFileName::GetPathSeparators
wxPathFormat  * wxFileNameGetPathSeparatorsformat0;
static wxString retwxFileNameGetPathSeparators0 = mywxFileName->GetPathSeparators( * wxFileNameGetPathSeparatorsformat0);
// Looking at method wxFileName::GetPathTerminators
wxPathFormat  * wxFileNameGetPathTerminatorsformat0;
static wxString retwxFileNameGetPathTerminators0 = mywxFileName->GetPathTerminators( * wxFileNameGetPathTerminatorsformat0);
// Looking at method wxFileName::GetShortPath
wxString retwxFileNameGetShortPath0 = mywxFileName->GetShortPath();
// Looking at method wxFileName::GetTimes
wxDateTime*  * wxFileNameGetTimesdtAccess0;
wxDateTime*  * wxFileNameGetTimesdtMod1;
wxDateTime*  * wxFileNameGetTimesdtCreate2;
bool retwxFileNameGetTimes0 = mywxFileName->GetTimes( * wxFileNameGetTimesdtAccess0,  * wxFileNameGetTimesdtMod1,  * wxFileNameGetTimesdtCreate2);
// Looking at method wxFileName::GetVolume
wxString retwxFileNameGetVolume0 = mywxFileName->GetVolume();
// Looking at method wxFileName::GetVolumeSeparator
wxPathFormat  * wxFileNameGetVolumeSeparatorformat0;
static wxString retwxFileNameGetVolumeSeparator0 = mywxFileName->GetVolumeSeparator( * wxFileNameGetVolumeSeparatorformat0);
// Looking at method wxFileName::HasExt
bool retwxFileNameHasExt0 = mywxFileName->HasExt();
// Looking at method wxFileName::HasName
bool retwxFileNameHasName0 = mywxFileName->HasName();
// Looking at method wxFileName::HasVolume
bool retwxFileNameHasVolume0 = mywxFileName->HasVolume();
// Looking at method wxFileName::InsertDir
size_t  * wxFileNameInsertDirbefore0;
wxString  * wxFileNameInsertDirdir1;
mywxFileName->InsertDir( * wxFileNameInsertDirbefore0,  * wxFileNameInsertDirdir1);
// Looking at method wxFileName::IsAbsolute
wxPathFormat  * wxFileNameIsAbsoluteformat0;
bool retwxFileNameIsAbsolute0 = mywxFileName->IsAbsolute( * wxFileNameIsAbsoluteformat0);
// Looking at method wxFileName::IsCaseSensitive
wxPathFormat  * wxFileNameIsCaseSensitiveformat0;
static bool retwxFileNameIsCaseSensitive0 = mywxFileName->IsCaseSensitive( * wxFileNameIsCaseSensitiveformat0);
// Looking at method wxFileName::IsOk
bool retwxFileNameIsOk0 = mywxFileName->IsOk();
// Looking at method wxFileName::IsPathSeparator
wxChar  * wxFileNameIsPathSeparatorch0;
wxPathFormat  * wxFileNameIsPathSeparatorformat1;
static bool retwxFileNameIsPathSeparator0 = mywxFileName->IsPathSeparator( * wxFileNameIsPathSeparatorch0,  * wxFileNameIsPathSeparatorformat1);
// Looking at method wxFileName::IsRelative
wxPathFormat  * wxFileNameIsRelativeformat0;
bool retwxFileNameIsRelative0 = mywxFileName->IsRelative( * wxFileNameIsRelativeformat0);
// Looking at method wxFileName::IsDir
bool retwxFileNameIsDir0 = mywxFileName->IsDir();
// Looking at method wxFileName::MakeAbsolute
wxString  * wxFileNameMakeAbsolutecwd0;
wxPathFormat  * wxFileNameMakeAbsoluteformat1;
bool retwxFileNameMakeAbsolute0 = mywxFileName->MakeAbsolute( * wxFileNameMakeAbsolutecwd0,  * wxFileNameMakeAbsoluteformat1);
// Looking at method wxFileName::MakeRelativeTo
wxString  * wxFileNameMakeRelativeTopathBase0;
wxPathFormat  * wxFileNameMakeRelativeToformat1;
bool retwxFileNameMakeRelativeTo0 = mywxFileName->MakeRelativeTo( * wxFileNameMakeRelativeTopathBase0,  * wxFileNameMakeRelativeToformat1);
// Looking at method wxFileName::Mkdir
int  * wxFileNameMkdirperm0;
int  * wxFileNameMkdirflags1;
bool retwxFileNameMkdir0 = mywxFileName->Mkdir( * wxFileNameMkdirperm0,  * wxFileNameMkdirflags1);
wxString  * wxFileNameMkdirdir2;
int  * wxFileNameMkdirperm3;
int  * wxFileNameMkdirflags4;
static bool retwxFileNameMkdir1 = mywxFileName->Mkdir( * wxFileNameMkdirdir2,  * wxFileNameMkdirperm3,  * wxFileNameMkdirflags4);
// Looking at method wxFileName::Normalize
int  * wxFileNameNormalizeflags0;
wxString  * wxFileNameNormalizecwd1;
wxPathFormat  * wxFileNameNormalizeformat2;
bool retwxFileNameNormalize0 = mywxFileName->Normalize( * wxFileNameNormalizeflags0,  * wxFileNameNormalizecwd1,  * wxFileNameNormalizeformat2);
// Looking at method wxFileName::PrependDir
wxString  * wxFileNamePrependDirdir0;
mywxFileName->PrependDir( * wxFileNamePrependDirdir0);
// Looking at method wxFileName::RemoveDir
size_t  * wxFileNameRemoveDirpos0;
mywxFileName->RemoveDir( * wxFileNameRemoveDirpos0);
// Looking at method wxFileName::RemoveLastDir
mywxFileName->RemoveLastDir();
// Looking at method wxFileName::Rmdir
bool retwxFileNameRmdir0 = mywxFileName->Rmdir();
wxString  * wxFileNameRmdirdir0;
static bool retwxFileNameRmdir1 = mywxFileName->Rmdir( * wxFileNameRmdirdir0);
// Looking at method wxFileName::SameAs
wxFileName  * wxFileNameSameAsfilepath0;
wxPathFormat  * wxFileNameSameAsformat1;
bool retwxFileNameSameAs0 = mywxFileName->SameAs( * wxFileNameSameAsfilepath0,  * wxFileNameSameAsformat1);
// Looking at method wxFileName::SetCwd
bool retwxFileNameSetCwd0 = mywxFileName->SetCwd();
wxString  * wxFileNameSetCwdcwd0;
static bool retwxFileNameSetCwd1 = mywxFileName->SetCwd( * wxFileNameSetCwdcwd0);
// Looking at method wxFileName::SetExt
wxString  * wxFileNameSetExtext0;
mywxFileName->SetExt( * wxFileNameSetExtext0);
// Looking at method wxFileName::SetFullName
wxString  * wxFileNameSetFullNamefullname0;
mywxFileName->SetFullName( * wxFileNameSetFullNamefullname0);
// Looking at method wxFileName::SetName
wxString  * wxFileNameSetNamename0;
mywxFileName->SetName( * wxFileNameSetNamename0);
// Looking at method wxFileName::SetTimes
wxDateTime*  * wxFileNameSetTimesdtAccess0;
wxDateTime*  * wxFileNameSetTimesdtMod1;
wxDateTime*  * wxFileNameSetTimesdtCreate2;
bool retwxFileNameSetTimes0 = mywxFileName->SetTimes( * wxFileNameSetTimesdtAccess0,  * wxFileNameSetTimesdtMod1,  * wxFileNameSetTimesdtCreate2);
// Looking at method wxFileName::SetVolume
wxString  * wxFileNameSetVolumevolume0;
mywxFileName->SetVolume( * wxFileNameSetVolumevolume0);
// Looking at method wxFileName::SplitPath
wxString  * wxFileNameSplitPathfullpath0;
wxString*  * wxFileNameSplitPathvolume1;
wxString*  * wxFileNameSplitPathpath2;
wxString*  * wxFileNameSplitPathname3;
wxString*  * wxFileNameSplitPathext4;
wxPathFormat  * wxFileNameSplitPathformat5;
mywxFileName->SplitPath( * wxFileNameSplitPathfullpath0,  * wxFileNameSplitPathvolume1,  * wxFileNameSplitPathpath2,  * wxFileNameSplitPathname3,  * wxFileNameSplitPathext4,  * wxFileNameSplitPathformat5);
wxString  * wxFileNameSplitPathfullpath6;
wxString*  * wxFileNameSplitPathpath7;
wxString*  * wxFileNameSplitPathname8;
wxString*  * wxFileNameSplitPathext9;
wxPathFormat  * wxFileNameSplitPathformat10;
mywxFileName->SplitPath( * wxFileNameSplitPathfullpath6,  * wxFileNameSplitPathpath7,  * wxFileNameSplitPathname8,  * wxFileNameSplitPathext9,  * wxFileNameSplitPathformat10);
// Looking at method wxFileName::SplitVolume
wxString  * wxFileNameSplitVolumefullpath0;
wxString*  * wxFileNameSplitVolumevolume1;
wxString*  * wxFileNameSplitVolumepath2;
wxPathFormat  * wxFileNameSplitVolumeformat3;
mywxFileName->SplitVolume( * wxFileNameSplitVolumefullpath0,  * wxFileNameSplitVolumevolume1,  * wxFileNameSplitVolumepath2,  * wxFileNameSplitVolumeformat3);
// Looking at method wxFileName::Touch
bool retwxFileNameTouch0 = mywxFileName->Touch();

// Looking at class wxFileOutputStream
wxFileOutputStream * mywxFileOutputStream;
// Looking at method wxFileOutputStream::wxFileOutputStream
wxString  * wxFileOutputStreamwxFileOutputStreamofileName0;
wxFileOutputStream * newwxFileOutputStream0 = new wxFileOutputStream( * wxFileOutputStreamwxFileOutputStreamofileName0);
wxFile  * wxFileOutputStreamwxFileOutputStreamfile1;
wxFileOutputStream * newwxFileOutputStream1 = new wxFileOutputStream( * wxFileOutputStreamwxFileOutputStreamfile1);
int  * wxFileOutputStreamwxFileOutputStreamfd2;
wxFileOutputStream * newwxFileOutputStream2 = new wxFileOutputStream( * wxFileOutputStreamwxFileOutputStreamfd2);
// Looking at method wxFileOutputStream::Ok
bool retwxFileOutputStreamOk0 = mywxFileOutputStream->Ok();

// Looking at class wxFileStream
wxFileStream * mywxFileStream;
// Looking at method wxFileStream::wxFileStream
wxString  * wxFileStreamwxFileStreamiofileName0;
wxFileStream * newwxFileStream0 = new wxFileStream( * wxFileStreamwxFileStreamiofileName0);

// Looking at class wxFileSystem
wxFileSystem * mywxFileSystem;
// Looking at method wxFileSystem::wxFileSystem
wxFileSystem * newwxFileSystem0 = new wxFileSystem();
// Looking at method wxFileSystem::AddHandler
wxFileSystemHandler * * wxFileSystemAddHandlerhandler0;
mywxFileSystem->AddHandler( * wxFileSystemAddHandlerhandler0);
// Looking at method wxFileSystem::ChangePathTo
wxString  * wxFileSystemChangePathTolocation0;
bool  * wxFileSystemChangePathTois_dir1;
mywxFileSystem->ChangePathTo( * wxFileSystemChangePathTolocation0,  * wxFileSystemChangePathTois_dir1);
// Looking at method wxFileSystem::GetPath
wxString retwxFileSystemGetPath0 = mywxFileSystem->GetPath();
// Looking at method wxFileSystem::FileNameToURL
wxFileName  * wxFileSystemFileNameToURLfilename0;
static wxString retwxFileSystemFileNameToURL0 = mywxFileSystem->FileNameToURL( * wxFileSystemFileNameToURLfilename0);
// Looking at method wxFileSystem::FindFirst
wxString  * wxFileSystemFindFirstwildcard0;
int  * wxFileSystemFindFirstflags1;
wxString retwxFileSystemFindFirst0 = mywxFileSystem->FindFirst( * wxFileSystemFindFirstwildcard0,  * wxFileSystemFindFirstflags1);
// Looking at method wxFileSystem::FindNext
wxString retwxFileSystemFindNext0 = mywxFileSystem->FindNext();
// Looking at method wxFileSystem::OpenFile
wxString  * wxFileSystemOpenFilelocation0;
wxFSFile* retwxFileSystemOpenFile0 = mywxFileSystem->OpenFile( * wxFileSystemOpenFilelocation0);
// Looking at method wxFileSystem::URLToFileName
wxString  * wxFileSystemURLToFileNameurl0;
static wxFileName retwxFileSystemURLToFileName0 = mywxFileSystem->URLToFileName( * wxFileSystemURLToFileNameurl0);

// Looking at class wxFilterOutputStream
wxFilterOutputStream * mywxFilterOutputStream;
// Looking at method wxFilterOutputStream::wxFilterOutputStream
wxOutputStream  * wxFilterOutputStreamwxFilterOutputStreamstream0;
wxFilterOutputStream * newwxFilterOutputStream0 = new wxFilterOutputStream( * wxFilterOutputStreamwxFilterOutputStreamstream0);

// Looking at class wxFindDialogEvent
wxFindDialogEvent * mywxFindDialogEvent;
// Looking at method wxFindDialogEvent::wxFindDialogEvent
wxEventType  * wxFindDialogEventwxFindDialogEventcommandType0;
int  * wxFindDialogEventwxFindDialogEventid1;
wxFindDialogEvent * newwxFindDialogEvent0 = new wxFindDialogEvent( * wxFindDialogEventwxFindDialogEventcommandType0,  * wxFindDialogEventwxFindDialogEventid1);
// Looking at method wxFindDialogEvent::GetFlags
int retwxFindDialogEventGetFlags0 = mywxFindDialogEvent->GetFlags();
// Looking at method wxFindDialogEvent::GetFindString
wxString retwxFindDialogEventGetFindString0 = mywxFindDialogEvent->GetFindString();
// Looking at method wxFindDialogEvent::GetReplaceString
const wxString retwxFindDialogEventGetReplaceString0 = mywxFindDialogEvent->GetReplaceString();
// Looking at method wxFindDialogEvent::GetDialog
wxFindReplaceDialog* retwxFindDialogEventGetDialog0 = mywxFindDialogEvent->GetDialog();

// Looking at class wxFindReplaceData
wxFindReplaceData * mywxFindReplaceData;
// Looking at method wxFindReplaceData::wxFindReplaceData
wxUint32  * wxFindReplaceDatawxFindReplaceDataflags0;
wxFindReplaceData * newwxFindReplaceData0 = new wxFindReplaceData( * wxFindReplaceDatawxFindReplaceDataflags0);
// Looking at method wxFindReplaceData::GetFindString
const wxString retwxFindReplaceDataGetFindString0 = mywxFindReplaceData->GetFindString();
// Looking at method wxFindReplaceData::GetReplaceString
const wxString retwxFindReplaceDataGetReplaceString0 = mywxFindReplaceData->GetReplaceString();
// Looking at method wxFindReplaceData::GetFlags
int retwxFindReplaceDataGetFlags0 = mywxFindReplaceData->GetFlags();
// Looking at method wxFindReplaceData::SetFlags
wxUint32  * wxFindReplaceDataSetFlagsflags0;
mywxFindReplaceData->SetFlags( * wxFindReplaceDataSetFlagsflags0);
// Looking at method wxFindReplaceData::SetFindString
wxString  * wxFindReplaceDataSetFindStringstr0;
mywxFindReplaceData->SetFindString( * wxFindReplaceDataSetFindStringstr0);
// Looking at method wxFindReplaceData::SetReplaceString
wxString  * wxFindReplaceDataSetReplaceStringstr0;
mywxFindReplaceData->SetReplaceString( * wxFindReplaceDataSetReplaceStringstr0);

// Looking at class wxFindReplaceDialog
wxFindReplaceDialog * mywxFindReplaceDialog;
// Looking at method wxFindReplaceDialog::wxFindReplaceDialog
wxFindReplaceDialog * newwxFindReplaceDialog0 = new wxFindReplaceDialog();
wxWindow *  * wxFindReplaceDialogwxFindReplaceDialogparent0;
wxFindReplaceData*  * wxFindReplaceDialogwxFindReplaceDialogdata1;
wxString  * wxFindReplaceDialogwxFindReplaceDialogtitle2;
int  * wxFindReplaceDialogwxFindReplaceDialogstyle3;
wxFindReplaceDialog * newwxFindReplaceDialog1 = new wxFindReplaceDialog( * wxFindReplaceDialogwxFindReplaceDialogparent0,  * wxFindReplaceDialogwxFindReplaceDialogdata1,  * wxFindReplaceDialogwxFindReplaceDialogtitle2,  * wxFindReplaceDialogwxFindReplaceDialogstyle3);
// Looking at method wxFindReplaceDialog::Create
wxWindow *  * wxFindReplaceDialogCreateparent0;
wxFindReplaceData*  * wxFindReplaceDialogCreatedata1;
wxString  * wxFindReplaceDialogCreatetitle2;
int  * wxFindReplaceDialogCreatestyle3;
bool retwxFindReplaceDialogCreate0 = mywxFindReplaceDialog->Create( * wxFindReplaceDialogCreateparent0,  * wxFindReplaceDialogCreatedata1,  * wxFindReplaceDialogCreatetitle2,  * wxFindReplaceDialogCreatestyle3);
// Looking at method wxFindReplaceDialog::GetData
const wxFindReplaceData* retwxFindReplaceDialogGetData0 = mywxFindReplaceDialog->GetData();

// Looking at class wxFlexGridSizer
wxFlexGridSizer * mywxFlexGridSizer;
// Looking at method wxFlexGridSizer::wxFlexGridSizer
int  * wxFlexGridSizerwxFlexGridSizerrows0;
int  * wxFlexGridSizerwxFlexGridSizercols1;
int  * wxFlexGridSizerwxFlexGridSizervgap2;
int  * wxFlexGridSizerwxFlexGridSizerhgap3;
wxFlexGridSizer * newwxFlexGridSizer0 = new wxFlexGridSizer( * wxFlexGridSizerwxFlexGridSizerrows0,  * wxFlexGridSizerwxFlexGridSizercols1,  * wxFlexGridSizerwxFlexGridSizervgap2,  * wxFlexGridSizerwxFlexGridSizerhgap3);
int  * wxFlexGridSizerwxFlexGridSizercols4;
int  * wxFlexGridSizerwxFlexGridSizervgap5;
int  * wxFlexGridSizerwxFlexGridSizerhgap6;
wxFlexGridSizer * newwxFlexGridSizer1 = new wxFlexGridSizer( * wxFlexGridSizerwxFlexGridSizercols4,  * wxFlexGridSizerwxFlexGridSizervgap5,  * wxFlexGridSizerwxFlexGridSizerhgap6);
// Looking at method wxFlexGridSizer::AddGrowableCol
size_t  * wxFlexGridSizerAddGrowableColidx0;
int  * wxFlexGridSizerAddGrowableColproportion1;
mywxFlexGridSizer->AddGrowableCol( * wxFlexGridSizerAddGrowableColidx0,  * wxFlexGridSizerAddGrowableColproportion1);
// Looking at method wxFlexGridSizer::AddGrowableRow
size_t  * wxFlexGridSizerAddGrowableRowidx0;
int  * wxFlexGridSizerAddGrowableRowproportion1;
mywxFlexGridSizer->AddGrowableRow( * wxFlexGridSizerAddGrowableRowidx0,  * wxFlexGridSizerAddGrowableRowproportion1);
// Looking at method wxFlexGridSizer::GetFlexibleDirection
int retwxFlexGridSizerGetFlexibleDirections0 = mywxFlexGridSizer->GetFlexibleDirections();
// Looking at method wxFlexGridSizer::GetNonFlexibleGrowMode
int retwxFlexGridSizerGetNonFlexibleGrowMode0 = mywxFlexGridSizer->GetNonFlexibleGrowMode();
// Looking at method wxFlexGridSizer::RemoveGrowableCol
size_t  * wxFlexGridSizerRemoveGrowableColidx0;
mywxFlexGridSizer->RemoveGrowableCol( * wxFlexGridSizerRemoveGrowableColidx0);
// Looking at method wxFlexGridSizer::RemoveGrowableRow
size_t  * wxFlexGridSizerRemoveGrowableRowidx0;
mywxFlexGridSizer->RemoveGrowableRow( * wxFlexGridSizerRemoveGrowableRowidx0);
// Looking at method wxFlexGridSizer::SetFlexibleDirection
int  * wxFlexGridSizerSetFlexibleDirectionsdirection0;
mywxFlexGridSizer->SetFlexibleDirections( * wxFlexGridSizerSetFlexibleDirectionsdirection0);
// Looking at method wxFlexGridSizer::SetNonFlexibleGrowMode
wxFlexSizerGrowMode  * wxFlexGridSizerSetNonFlexibleGrowModemode0;
mywxFlexGridSizer->SetNonFlexibleGrowMode( * wxFlexGridSizerSetNonFlexibleGrowModemode0);

// Looking at class wxFocusEvent
wxFocusEvent * mywxFocusEvent;
// Looking at method wxFocusEvent::wxFocusEvent
WXTYPE  * wxFocusEventwxFocusEventeventType0;
int  * wxFocusEventwxFocusEventid1;
wxFocusEvent * newwxFocusEvent0 = new wxFocusEvent( * wxFocusEventwxFocusEventeventType0,  * wxFocusEventwxFocusEventid1);
// Looking at method wxFocusEvent::GetWindow

// Looking at class wxFont
wxFont * mywxFont;
// Looking at method wxFont::wxFont
wxFont * newwxFont0 = new wxFont();
int  * wxFontwxFontpointSize0;
wxFontFamily  * wxFontwxFontfamily1;
int  * wxFontwxFontstyle2;
int  * wxFontwxFontweight3;
bool  * wxFontwxFontunderline4;
wxString  * wxFontwxFontfaceName5;
wxFontEncoding  * wxFontwxFontencoding6;
wxFont * newwxFont1 = new wxFont( * wxFontwxFontpointSize0,  * wxFontwxFontfamily1,  * wxFontwxFontstyle2,  * wxFontwxFontweight3,  * wxFontwxFontunderline4,  * wxFontwxFontfaceName5,  * wxFontwxFontencoding6);
int  * wxFontwxFontpixelSize7;
int  * wxFontwxFontfamily8;
int  * wxFontwxFontstyle9;
int  * wxFontwxFontweight10;
bool  * wxFontwxFontunderline11;
wxString  * wxFontwxFontfaceName12;
wxFontEncoding  * wxFontwxFontencoding13;
wxFont * newwxFont2 = new wxFont( * wxFontwxFontpixelSize7,  * wxFontwxFontfamily8,  * wxFontwxFontstyle9,  * wxFontwxFontweight10,  * wxFontwxFontunderline11,  * wxFontwxFontfaceName12,  * wxFontwxFontencoding13);
// Looking at method wxFont::IsFixedWidth
bool retwxFontIsFixedWidth0 = mywxFont->IsFixedWidth();
// Looking at method wxFont::GetDefaultEncoding
static wxFontEncoding retwxFontGetDefaultEncoding0 = mywxFont->GetDefaultEncoding();
// Looking at method wxFont::GetFaceName
wxString retwxFontGetFaceName0 = mywxFont->GetFaceName();
// Looking at method wxFont::GetFamily
int retwxFontGetFamily0 = mywxFont->GetFamily();
// Looking at method wxFont::GetNativeFontInfoDesc
wxString retwxFontGetNativeFontInfoDesc0 = mywxFont->GetNativeFontInfoDesc();
// Looking at method wxFont::GetPointSize
int retwxFontGetPointSize0 = mywxFont->GetPointSize();
// Looking at method wxFont::GetStyle
int retwxFontGetStyle0 = mywxFont->GetStyle();
// Looking at method wxFont::GetUnderlined
bool retwxFontGetUnderlined0 = mywxFont->GetUnderlined();
// Looking at method wxFont::GetWeight
int retwxFontGetWeight0 = mywxFont->GetWeight();
// Looking at method wxFont::New
int  * wxFontNewpointSize0;
wxFontFamily  * wxFontNewfamily1;
int  * wxFontNewstyle2;
int  * wxFontNewweight3;
bool  * wxFontNewunderline4;
wxString  * wxFontNewfaceName5;
wxFontEncoding  * wxFontNewencoding6;
static wxFont * retwxFontNew0 = mywxFont->New( * wxFontNewpointSize0,  * wxFontNewfamily1,  * wxFontNewstyle2,  * wxFontNewweight3,  * wxFontNewunderline4,  * wxFontNewfaceName5,  * wxFontNewencoding6);
int  * wxFontNewpointSize7;
wxFontFamily  * wxFontNewfamily8;
int  * wxFontNewflags9;
wxString  * wxFontNewfaceName10;
wxFontEncoding  * wxFontNewencoding11;
static wxFont * retwxFontNew1 = mywxFont->New( * wxFontNewpointSize7,  * wxFontNewfamily8,  * wxFontNewflags9,  * wxFontNewfaceName10,  * wxFontNewencoding11);
wxSize  * wxFontNewpixelSize12;
wxFontFamily  * wxFontNewfamily13;
int  * wxFontNewstyle14;
int  * wxFontNewweight15;
bool  * wxFontNewunderline16;
wxString  * wxFontNewfaceName17;
wxFontEncoding  * wxFontNewencoding18;
static wxFont * retwxFontNew2 = mywxFont->New( * wxFontNewpixelSize12,  * wxFontNewfamily13,  * wxFontNewstyle14,  * wxFontNewweight15,  * wxFontNewunderline16,  * wxFontNewfaceName17,  * wxFontNewencoding18);
wxSize  * wxFontNewpixelSize19;
wxFontFamily  * wxFontNewfamily20;
int  * wxFontNewflags21;
wxString  * wxFontNewfaceName22;
wxFontEncoding  * wxFontNewencoding23;
static wxFont * retwxFontNew3 = mywxFont->New( * wxFontNewpixelSize19,  * wxFontNewfamily20,  * wxFontNewflags21,  * wxFontNewfaceName22,  * wxFontNewencoding23);
// Looking at method wxFont::Ok
bool retwxFontOk0 = mywxFont->Ok();
// Looking at method wxFont::SetDefaultEncoding
wxFontEncoding  * wxFontSetDefaultEncodingencoding0;
mywxFont->SetDefaultEncoding( * wxFontSetDefaultEncodingencoding0);
// Looking at method wxFont::SetFaceName
wxString  * wxFontSetFaceNamefaceName0;
mywxFont->SetFaceName( * wxFontSetFaceNamefaceName0);
// Looking at method wxFont::SetFamily
int  * wxFontSetFamilyfamily0;
mywxFont->SetFamily( * wxFontSetFamilyfamily0);
// Looking at method wxFont::SetNativeFontInfo
wxString  * wxFontSetNativeFontInfoinfo0;
mywxFont->SetNativeFontInfo( * wxFontSetNativeFontInfoinfo0);
// Looking at method wxFont::SetPointSize
int  * wxFontSetPointSizepointSize0;
mywxFont->SetPointSize( * wxFontSetPointSizepointSize0);
// Looking at method wxFont::SetStyle
int  * wxFontSetStylestyle0;
mywxFont->SetStyle( * wxFontSetStylestyle0);
// Looking at method wxFont::SetUnderlined
bool  * wxFontSetUnderlinedunderlined0;
mywxFont->SetUnderlined( * wxFontSetUnderlinedunderlined0);
// Looking at method wxFont::SetWeight
int  * wxFontSetWeightweight0;
mywxFont->SetWeight( * wxFontSetWeightweight0);

// Looking at class wxFontData
wxFontData * mywxFontData;
// Looking at method wxFontData::wxFontData
wxFontData * newwxFontData0 = new wxFontData();
// Looking at method wxFontData::EnableEffects
bool  * wxFontDataEnableEffectsenable0;
mywxFontData->EnableEffects( * wxFontDataEnableEffectsenable0);
// Looking at method wxFontData::GetAllowSymbols
bool retwxFontDataGetAllowSymbols0 = mywxFontData->GetAllowSymbols();
// Looking at method wxFontData::GetColour
wxColour retwxFontDataGetColour0 = mywxFontData->GetColour();
// Looking at method wxFontData::GetChosenFont
wxFont retwxFontDataGetChosenFont0 = mywxFontData->GetChosenFont();
// Looking at method wxFontData::GetEnableEffects
bool retwxFontDataGetEnableEffects0 = mywxFontData->GetEnableEffects();
// Looking at method wxFontData::GetInitialFont
wxFont retwxFontDataGetInitialFont0 = mywxFontData->GetInitialFont();
// Looking at method wxFontData::GetShowHelp
bool retwxFontDataGetShowHelp0 = mywxFontData->GetShowHelp();
// Looking at method wxFontData::SetAllowSymbols
bool  * wxFontDataSetAllowSymbolsallowSymbols0;
mywxFontData->SetAllowSymbols( * wxFontDataSetAllowSymbolsallowSymbols0);
// Looking at method wxFontData::SetChosenFont
wxFont  * wxFontDataSetChosenFontfont0;
mywxFontData->SetChosenFont( * wxFontDataSetChosenFontfont0);
// Looking at method wxFontData::SetColour
wxColour  * wxFontDataSetColourcolour0;
mywxFontData->SetColour( * wxFontDataSetColourcolour0);
// Looking at method wxFontData::SetInitialFont
wxFont * wxFontDataSetInitialFontfont0;
mywxFontData->SetInitialFont( * wxFontDataSetInitialFontfont0);
// Looking at method wxFontData::SetRange
int  * wxFontDataSetRangemin0;
int  * wxFontDataSetRangemax1;
mywxFontData->SetRange( * wxFontDataSetRangemin0,  * wxFontDataSetRangemax1);
// Looking at method wxFontData::SetShowHelp
bool  * wxFontDataSetShowHelpshowHelp0;
mywxFontData->SetShowHelp( * wxFontDataSetShowHelpshowHelp0);

// Looking at class wxFontDialog
wxFontDialog * mywxFontDialog;
// Looking at method wxFontDialog::wxFontDialog
wxFontDialog * newwxFontDialog0 = new wxFontDialog();
wxWindow*  * wxFontDialogwxFontDialogparent0;
wxFontDialog * newwxFontDialog1 = new wxFontDialog( * wxFontDialogwxFontDialogparent0);
wxWindow*  * wxFontDialogwxFontDialogparent1;
wxFontData  * wxFontDialogwxFontDialogdata2;
wxFontDialog * newwxFontDialog2 = new wxFontDialog( * wxFontDialogwxFontDialogparent1,  * wxFontDialogwxFontDialogdata2);
// Looking at method wxFontDialog::Create
wxWindow*  * wxFontDialogCreateparent0;
bool retwxFontDialogCreate0 = mywxFontDialog->Create( * wxFontDialogCreateparent0);
wxWindow*  * wxFontDialogCreateparent1;
wxFontData  * wxFontDialogCreatedata2;
bool retwxFontDialogCreate1 = mywxFontDialog->Create( * wxFontDialogCreateparent1,  * wxFontDialogCreatedata2);
// Looking at method wxFontDialog::GetFontData
const wxFontData retwxFontDialogGetFontData0 = mywxFontDialog->GetFontData();
wxFontData retwxFontDialogGetFontData1 = mywxFontDialog->GetFontData();
// Looking at method wxFontDialog::ShowModal
int retwxFontDialogShowModal0 = mywxFontDialog->ShowModal();

// Looking at class wxFontEnumerator
wxFontEnumerator * mywxFontEnumerator;
// Looking at method wxFontEnumerator::EnumerateFacenames
// Looking at method wxFontEnumerator::EnumerateEncodings
// Looking at method wxFontEnumerator::GetEncodings
wxArrayString* retwxFontEnumeratorGetEncodings0 = mywxFontEnumerator->GetEncodings();
// Looking at method wxFontEnumerator::GetFacenames
wxArrayString* retwxFontEnumeratorGetFacenames0 = mywxFontEnumerator->GetFacenames();
// Looking at method wxFontEnumerator::OnFacename
// Looking at method wxFontEnumerator::OnFontEncoding

// Looking at class wxFontList
wxFontList * mywxFontList;
// Looking at method wxFontList::wxFontList
wxFontList * newwxFontList0 = new wxFontList();
// Looking at method wxFontList::AddFont
wxFont * * wxFontListAddFontfont0;
mywxFontList->AddFont( * wxFontListAddFontfont0);
// Looking at method wxFontList::FindOrCreateFont
int  * wxFontListFindOrCreateFontpoint_size0;
int  * wxFontListFindOrCreateFontfamily1;
int  * wxFontListFindOrCreateFontstyle2;
int  * wxFontListFindOrCreateFontweight3;
bool  * wxFontListFindOrCreateFontunderline4;
wxString  * wxFontListFindOrCreateFontfacename5;
wxFontEncoding  * wxFontListFindOrCreateFontencoding6;
wxFont * retwxFontListFindOrCreateFont0 = mywxFontList->FindOrCreateFont( * wxFontListFindOrCreateFontpoint_size0,  * wxFontListFindOrCreateFontfamily1,  * wxFontListFindOrCreateFontstyle2,  * wxFontListFindOrCreateFontweight3,  * wxFontListFindOrCreateFontunderline4,  * wxFontListFindOrCreateFontfacename5,  * wxFontListFindOrCreateFontencoding6);
// Looking at method wxFontList::RemoveFont
wxFont * * wxFontListRemoveFontfont0;
mywxFontList->RemoveFont( * wxFontListRemoveFontfont0);

// Looking at class wxFontMapper
wxFontMapper * mywxFontMapper;
// Looking at method wxFontMapper::wxFontMapper
wxFontMapper * newwxFontMapper0 = new wxFontMapper();
// Looking at method wxFontMapper::CharsetToEncoding
wxString  * wxFontMapperCharsetToEncodingcharset0;
bool  * wxFontMapperCharsetToEncodinginteractive1;
wxFontEncoding retwxFontMapperCharsetToEncoding0 = mywxFontMapper->CharsetToEncoding( * wxFontMapperCharsetToEncodingcharset0,  * wxFontMapperCharsetToEncodinginteractive1);
// Looking at method wxFontMapper::Get
static wxFontMapper * retwxFontMapperGet0 = mywxFontMapper->Get();
// Looking at method wxFontMapper::GetAltForEncoding
wxFontEncoding  * wxFontMapperGetAltForEncodingencoding0;
wxNativeEncodingInfo*  * wxFontMapperGetAltForEncodinginfo1;
wxString  * wxFontMapperGetAltForEncodingfacename2;
bool  * wxFontMapperGetAltForEncodinginteractive3;
bool retwxFontMapperGetAltForEncoding0 = mywxFontMapper->GetAltForEncoding( * wxFontMapperGetAltForEncodingencoding0,  * wxFontMapperGetAltForEncodinginfo1,  * wxFontMapperGetAltForEncodingfacename2,  * wxFontMapperGetAltForEncodinginteractive3);
wxFontEncoding  * wxFontMapperGetAltForEncodingencoding4;
wxFontEncoding*  * wxFontMapperGetAltForEncodingalt_encoding5;
wxString  * wxFontMapperGetAltForEncodingfacename6;
bool  * wxFontMapperGetAltForEncodinginteractive7;
bool retwxFontMapperGetAltForEncoding1 = mywxFontMapper->GetAltForEncoding( * wxFontMapperGetAltForEncodingencoding4,  * wxFontMapperGetAltForEncodingalt_encoding5,  * wxFontMapperGetAltForEncodingfacename6,  * wxFontMapperGetAltForEncodinginteractive7);
// Looking at method wxFontMapper::GetEncoding
size_t  * wxFontMapperGetEncodingn0;
static wxFontEncoding retwxFontMapperGetEncoding0 = mywxFontMapper->GetEncoding( * wxFontMapperGetEncodingn0);
// Looking at method wxFontMapper::GetEncodingDescription
wxFontEncoding  * wxFontMapperGetEncodingDescriptionencoding0;
static wxString retwxFontMapperGetEncodingDescription0 = mywxFontMapper->GetEncodingDescription( * wxFontMapperGetEncodingDescriptionencoding0);
// Looking at method wxFontMapper::GetEncodingFromName
wxString  * wxFontMapperGetEncodingFromNameencoding0;
static wxFontEncoding retwxFontMapperGetEncodingFromName0 = mywxFontMapper->GetEncodingFromName( * wxFontMapperGetEncodingFromNameencoding0);
// Looking at method wxFontMapper::GetEncodingName
wxFontEncoding  * wxFontMapperGetEncodingNameencoding0;
static wxString retwxFontMapperGetEncodingName0 = mywxFontMapper->GetEncodingName( * wxFontMapperGetEncodingNameencoding0);
// Looking at method wxFontMapper::GetSupportedEncodingsCount
static size_t retwxFontMapperGetSupportedEncodingsCount0 = mywxFontMapper->GetSupportedEncodingsCount();
// Looking at method wxFontMapper::IsEncodingAvailable
wxFontEncoding  * wxFontMapperIsEncodingAvailableencoding0;
wxString  * wxFontMapperIsEncodingAvailablefacename1;
bool retwxFontMapperIsEncodingAvailable0 = mywxFontMapper->IsEncodingAvailable( * wxFontMapperIsEncodingAvailableencoding0,  * wxFontMapperIsEncodingAvailablefacename1);
// Looking at method wxFontMapper::SetDialogParent
wxWindow*  * wxFontMapperSetDialogParentparent0;
mywxFontMapper->SetDialogParent( * wxFontMapperSetDialogParentparent0);
// Looking at method wxFontMapper::SetDialogTitle
wxString  * wxFontMapperSetDialogTitletitle0;
mywxFontMapper->SetDialogTitle( * wxFontMapperSetDialogTitletitle0);
// Looking at method wxFontMapper::Set
wxFontMapper * * wxFontMapperSetmapper0;
static wxFontMapper * retwxFontMapperSet0 = mywxFontMapper->Set( * wxFontMapperSetmapper0);
// Looking at method wxFontMapper::SetConfig
wxConfigBase*  * wxFontMapperSetConfigconfig0;
mywxFontMapper->SetConfig( * wxFontMapperSetConfigconfig0);
// Looking at method wxFontMapper::SetConfigPath
wxString  * wxFontMapperSetConfigPathprefix0;
mywxFontMapper->SetConfigPath( * wxFontMapperSetConfigPathprefix0);

// Looking at class wxFrame
wxFrame * mywxFrame;
// Looking at method wxFrame::wxFrame
wxFrame * newwxFrame0 = new wxFrame();
wxWindow*  * wxFramewxFrameparent0;
wxWindowID  * wxFramewxFrameid1;
wxString  * wxFramewxFrametitle2;
wxPoint  * wxFramewxFramepos3;
wxSize  * wxFramewxFramesize4;
long  * wxFramewxFramestyle5;
wxString  * wxFramewxFramename6;
wxFrame * newwxFrame1 = new wxFrame( * wxFramewxFrameparent0,  * wxFramewxFrameid1,  * wxFramewxFrametitle2,  * wxFramewxFramepos3,  * wxFramewxFramesize4,  * wxFramewxFramestyle5,  * wxFramewxFramename6);
// Looking at method wxFrame::Centre
int  * wxFrameCentredirection0;
mywxFrame->Centre( * wxFrameCentredirection0);
// Looking at method wxFrame::Create
wxWindow*  * wxFrameCreateparent0;
wxWindowID  * wxFrameCreateid1;
wxString  * wxFrameCreatetitle2;
wxPoint  * wxFrameCreatepos3;
wxSize  * wxFrameCreatesize4;
long  * wxFrameCreatestyle5;
wxString  * wxFrameCreatename6;
bool retwxFrameCreate0 = mywxFrame->Create( * wxFrameCreateparent0,  * wxFrameCreateid1,  * wxFrameCreatetitle2,  * wxFrameCreatepos3,  * wxFrameCreatesize4,  * wxFrameCreatestyle5,  * wxFrameCreatename6);
// Looking at method wxFrame::CreateStatusBar
// Looking at method wxFrame::CreateToolBar
// Looking at method wxFrame::GetClientAreaOrigin
wxPoint retwxFrameGetClientAreaOrigin0 = mywxFrame->GetClientAreaOrigin();
// Looking at method wxFrame::GetMenuBar
wxMenuBar* retwxFrameGetMenuBar0 = mywxFrame->GetMenuBar();
// Looking at method wxFrame::GetStatusBar
wxStatusBar* retwxFrameGetStatusBar0 = mywxFrame->GetStatusBar();
// Looking at method wxFrame::GetStatusBarPane
int retwxFrameGetStatusBarPane0 = mywxFrame->GetStatusBarPane();
// Looking at method wxFrame::GetToolBar
wxToolBar* retwxFrameGetToolBar0 = mywxFrame->GetToolBar();
// Looking at method wxFrame::OnCreateStatusBar
// Looking at method wxFrame::OnCreateToolBar
// Looking at method wxFrame::ProcessCommand
int  * wxFrameProcessCommandid0;
mywxFrame->ProcessCommand( * wxFrameProcessCommandid0);
// Looking at method wxFrame::SendSizeEvent
mywxFrame->SendSizeEvent();
// Looking at method wxFrame::SetMenuBar
wxMenuBar*  * wxFrameSetMenuBarmenuBar0;
mywxFrame->SetMenuBar( * wxFrameSetMenuBarmenuBar0);
// Looking at method wxFrame::SetStatusBar
wxStatusBar*  * wxFrameSetStatusBarstatusBar0;
mywxFrame->SetStatusBar( * wxFrameSetStatusBarstatusBar0);
// Looking at method wxFrame::SetStatusBarPane
int  * wxFrameSetStatusBarPanen0;
mywxFrame->SetStatusBarPane( * wxFrameSetStatusBarPanen0);
// Looking at method wxFrame::SetStatusText
// Looking at method wxFrame::SetStatusWidths
// Looking at method wxFrame::SetToolBar
wxToolBar*  * wxFrameSetToolBartoolBar0;
mywxFrame->SetToolBar( * wxFrameSetToolBartoolBar0);

// Looking at class wxGBPosition
wxGBPosition * mywxGBPosition;
// Looking at method wxGBPosition::wxGBPosition
wxGBPosition * newwxGBPosition0 = new wxGBPosition();
int  * wxGBPositionwxGBPositionrow0;
int  * wxGBPositionwxGBPositioncol1;
wxGBPosition * newwxGBPosition1 = new wxGBPosition( * wxGBPositionwxGBPositionrow0,  * wxGBPositionwxGBPositioncol1);
// Looking at method wxGBPosition::GetCol
int retwxGBPositionGetCol0 = mywxGBPosition->GetCol();
// Looking at method wxGBPosition::GetRow
int retwxGBPositionGetRow0 = mywxGBPosition->GetRow();
// Looking at method wxGBPosition::SetCol
int  * wxGBPositionSetColcol0;
mywxGBPosition->SetCol( * wxGBPositionSetColcol0);
// Looking at method wxGBPosition::SetRow
int  * wxGBPositionSetRowrow0;
mywxGBPosition->SetRow( * wxGBPositionSetRowrow0);

// Looking at class wxGBSizerItem
wxGBSizerItem * mywxGBSizerItem;
// Looking at method wxGBSizerItem::wxGBSizerItem
int  * wxGBSizerItemwxGBSizerItemwidth0;
int  * wxGBSizerItemwxGBSizerItemheight1;
wxGBPosition  * wxGBSizerItemwxGBSizerItempos2;
wxGBSpan  * wxGBSizerItemwxGBSizerItemspan3;
int  * wxGBSizerItemwxGBSizerItemflag4;
int  * wxGBSizerItemwxGBSizerItemborder5;
wxObject*  * wxGBSizerItemwxGBSizerItemuserData6;
wxGBSizerItem * newwxGBSizerItem0 = new wxGBSizerItem( * wxGBSizerItemwxGBSizerItemwidth0,  * wxGBSizerItemwxGBSizerItemheight1,  * wxGBSizerItemwxGBSizerItempos2,  * wxGBSizerItemwxGBSizerItemspan3,  * wxGBSizerItemwxGBSizerItemflag4,  * wxGBSizerItemwxGBSizerItemborder5,  * wxGBSizerItemwxGBSizerItemuserData6);
wxWindow*  * wxGBSizerItemwxGBSizerItemwindow7;
wxGBPosition  * wxGBSizerItemwxGBSizerItempos8;
wxGBSpan  * wxGBSizerItemwxGBSizerItemspan9;
int  * wxGBSizerItemwxGBSizerItemflag10;
int  * wxGBSizerItemwxGBSizerItemborder11;
wxObject*  * wxGBSizerItemwxGBSizerItemuserData12;
wxGBSizerItem * newwxGBSizerItem1 = new wxGBSizerItem( * wxGBSizerItemwxGBSizerItemwindow7,  * wxGBSizerItemwxGBSizerItempos8,  * wxGBSizerItemwxGBSizerItemspan9,  * wxGBSizerItemwxGBSizerItemflag10,  * wxGBSizerItemwxGBSizerItemborder11,  * wxGBSizerItemwxGBSizerItemuserData12);
wxSizer*  * wxGBSizerItemwxGBSizerItemsizer13;
wxGBPosition  * wxGBSizerItemwxGBSizerItempos14;
wxGBSpan  * wxGBSizerItemwxGBSizerItemspan15;
int  * wxGBSizerItemwxGBSizerItemflag16;
int  * wxGBSizerItemwxGBSizerItemborder17;
wxObject*  * wxGBSizerItemwxGBSizerItemuserData18;
wxGBSizerItem * newwxGBSizerItem2 = new wxGBSizerItem( * wxGBSizerItemwxGBSizerItemsizer13,  * wxGBSizerItemwxGBSizerItempos14,  * wxGBSizerItemwxGBSizerItemspan15,  * wxGBSizerItemwxGBSizerItemflag16,  * wxGBSizerItemwxGBSizerItemborder17,  * wxGBSizerItemwxGBSizerItemuserData18);
// Looking at method wxGBSizerItem::GetEndPos
int  * wxGBSizerItemGetEndPosrow0;
int  * wxGBSizerItemGetEndPoscol1;
mywxGBSizerItem->GetEndPos( * wxGBSizerItemGetEndPosrow0,  * wxGBSizerItemGetEndPoscol1);
// Looking at method wxGBSizerItem::GetPos
wxGBPosition retwxGBSizerItemGetPos0 = mywxGBSizerItem->GetPos();
int  * wxGBSizerItemGetPosrow0;
int  * wxGBSizerItemGetPoscol1;
mywxGBSizerItem->GetPos( * wxGBSizerItemGetPosrow0,  * wxGBSizerItemGetPoscol1);
// Looking at method wxGBSizerItem::GetSpan
wxGBSpan retwxGBSizerItemGetSpan0 = mywxGBSizerItem->GetSpan();
int  * wxGBSizerItemGetSpanrowspan0;
int  * wxGBSizerItemGetSpancolspan1;
mywxGBSizerItem->GetSpan( * wxGBSizerItemGetSpanrowspan0,  * wxGBSizerItemGetSpancolspan1);
// Looking at method wxGBSizerItem::Intersects
wxGBSizerItem  * wxGBSizerItemIntersectsother0;
bool retwxGBSizerItemIntersects0 = mywxGBSizerItem->Intersects( * wxGBSizerItemIntersectsother0);
wxGBPosition  * wxGBSizerItemIntersectspos1;
wxGBSpan  * wxGBSizerItemIntersectsspan2;
bool retwxGBSizerItemIntersects1 = mywxGBSizerItem->Intersects( * wxGBSizerItemIntersectspos1,  * wxGBSizerItemIntersectsspan2);
// Looking at method wxGBSizerItem::SetPos
wxGBPosition  * wxGBSizerItemSetPospos0;
bool retwxGBSizerItemSetPos0 = mywxGBSizerItem->SetPos( * wxGBSizerItemSetPospos0);
// Looking at method wxGBSizerItem::SetSpan
wxGBSpan  * wxGBSizerItemSetSpanspan0;
bool retwxGBSizerItemSetSpan0 = mywxGBSizerItem->SetSpan( * wxGBSizerItemSetSpanspan0);

// Looking at class wxGBSpan
wxGBSpan * mywxGBSpan;
// Looking at method wxGBSpan::wxGBSpan
wxGBSpan * newwxGBSpan0 = new wxGBSpan();
int  * wxGBSpanwxGBSpanrowspan0;
int  * wxGBSpanwxGBSpancolspan1;
wxGBSpan * newwxGBSpan1 = new wxGBSpan( * wxGBSpanwxGBSpanrowspan0,  * wxGBSpanwxGBSpancolspan1);
// Looking at method wxGBSpan::GetColspan
int retwxGBSpanGetColspan0 = mywxGBSpan->GetColspan();
// Looking at method wxGBSpan::GetRowspan
int retwxGBSpanGetRowspan0 = mywxGBSpan->GetRowspan();
// Looking at method wxGBSpan::SetColspan
int  * wxGBSpanSetColspancolspan0;
mywxGBSpan->SetColspan( * wxGBSpanSetColspancolspan0);
// Looking at method wxGBSpan::SetRowspan
int  * wxGBSpanSetRowspanrowspan0;
mywxGBSpan->SetRowspan( * wxGBSpanSetRowspanrowspan0);

// Looking at class wxGDIObject
wxGDIObject * mywxGDIObject;
// Looking at method wxGDIObject::wxGDIObject
wxGDIObject * newwxGDIObject0 = new wxGDIObject();
#if wxUSE_GLCANVAS == 1

// Looking at class wxGLCanvas
wxGLCanvas * mywxGLCanvas;
// Looking at method wxGLCanvas::wxGLCanvas
wxWindow*  * wxGLCanvaswxGLCanvasparent0;
wxWindowID  * wxGLCanvaswxGLCanvasid1;
wxPoint  * wxGLCanvaswxGLCanvaspos2;
wxSize  * wxGLCanvaswxGLCanvassize3;
long  * wxGLCanvaswxGLCanvasstyle4;
wxString  * wxGLCanvaswxGLCanvasname5;
int*  * wxGLCanvaswxGLCanvasattribList6;
wxPalette  * wxGLCanvaswxGLCanvaspalette7;
mywxGLCanvas->wxGLCanvas( * wxGLCanvaswxGLCanvasparent0,  * wxGLCanvaswxGLCanvasid1,  * wxGLCanvaswxGLCanvaspos2,  * wxGLCanvaswxGLCanvassize3,  * wxGLCanvaswxGLCanvasstyle4,  * wxGLCanvaswxGLCanvasname5,  * wxGLCanvaswxGLCanvasattribList6,  * wxGLCanvaswxGLCanvaspalette7);
wxWindow*  * wxGLCanvaswxGLCanvasparent8;
wxGLCanvas*   * wxGLCanvaswxGLCanvassharedCanvas9;
wxWindowID  * wxGLCanvaswxGLCanvasid10;
wxPoint  * wxGLCanvaswxGLCanvaspos11;
wxSize  * wxGLCanvaswxGLCanvassize12;
long  * wxGLCanvaswxGLCanvasstyle13;
wxString  * wxGLCanvaswxGLCanvasname14;
int*  * wxGLCanvaswxGLCanvasattribList15;
wxPalette  * wxGLCanvaswxGLCanvaspalette16;
mywxGLCanvas->wxGLCanvas( * wxGLCanvaswxGLCanvasparent8,  * wxGLCanvaswxGLCanvassharedCanvas9,  * wxGLCanvaswxGLCanvasid10,  * wxGLCanvaswxGLCanvaspos11,  * wxGLCanvaswxGLCanvassize12,  * wxGLCanvaswxGLCanvasstyle13,  * wxGLCanvaswxGLCanvasname14,  * wxGLCanvaswxGLCanvasattribList15,  * wxGLCanvaswxGLCanvaspalette16);
wxWindow*  * wxGLCanvaswxGLCanvasparent17;
wxGLContext*   * wxGLCanvaswxGLCanvassharedContext18;
wxWindowID  * wxGLCanvaswxGLCanvasid19;
wxPoint  * wxGLCanvaswxGLCanvaspos20;
wxSize  * wxGLCanvaswxGLCanvassize21;
long  * wxGLCanvaswxGLCanvasstyle22;
wxString  * wxGLCanvaswxGLCanvasname23;
int*  * wxGLCanvaswxGLCanvasattribList24;
wxPalette  * wxGLCanvaswxGLCanvaspalette25;
mywxGLCanvas->wxGLCanvas( * wxGLCanvaswxGLCanvasparent17,  * wxGLCanvaswxGLCanvassharedContext18,  * wxGLCanvaswxGLCanvasid19,  * wxGLCanvaswxGLCanvaspos20,  * wxGLCanvaswxGLCanvassize21,  * wxGLCanvaswxGLCanvasstyle22,  * wxGLCanvaswxGLCanvasname23,  * wxGLCanvaswxGLCanvasattribList24,  * wxGLCanvaswxGLCanvaspalette25);
// Looking at method wxGLCanvas::GetContext
wxGLContext* retwxGLCanvasGetContext0 = mywxGLCanvas->GetContext();
// Looking at method wxGLCanvas::SetCurrent
mywxGLCanvas->SetCurrent();
// Looking at method wxGLCanvas::SetColour
char*  * wxGLCanvasSetColourcolour0;
mywxGLCanvas->SetColour( * wxGLCanvasSetColourcolour0);
// Looking at method wxGLCanvas::SwapBuffers
mywxGLCanvas->SwapBuffers();
#endif //wxUSE_GLCANVAS
#if wxUSE_GLCANVAS == 1

// Looking at class wxGLContext
wxGLContext * mywxGLContext;
// Looking at method wxGLContext::wxGLContext
bool  * wxGLContextwxGLContextisRGB0;
wxGLCanvas*  * wxGLContextwxGLContextwin1;
wxPalette  * wxGLContextwxGLContextpalette2;
mywxGLContext->wxGLContext( * wxGLContextwxGLContextisRGB0,  * wxGLContextwxGLContextwin1,  * wxGLContextwxGLContextpalette2);
bool  * wxGLContextwxGLContextisRGB3;
wxGLCanvas*  * wxGLContextwxGLContextwin4;
wxPalette  * wxGLContextwxGLContextpalette5;
wxGLContext*  * wxGLContextwxGLContextother6;
mywxGLContext->wxGLContext( * wxGLContextwxGLContextisRGB3,  * wxGLContextwxGLContextwin4,  * wxGLContextwxGLContextpalette5,  * wxGLContextwxGLContextother6);
// Looking at method wxGLContext::GetWindow
const wxWindow* retwxGLContextGetWindow0 = mywxGLContext->GetWindow();
// Looking at method wxGLContext::SetCurrent
mywxGLContext->SetCurrent();
// Looking at method wxGLContext::SetColour
char*  * wxGLContextSetColourcolour0;
mywxGLContext->SetColour( * wxGLContextSetColourcolour0);
// Looking at method wxGLContext::SwapBuffers
mywxGLContext->SwapBuffers();
#endif //wxUSE_GLCANVAS

// Looking at class wxGauge
wxGauge * mywxGauge;
// Looking at method wxGauge::wxGauge
wxGauge * newwxGauge0 = new wxGauge();
wxWindow*  * wxGaugewxGaugeparent0;
wxWindowID  * wxGaugewxGaugeid1;
int  * wxGaugewxGaugerange2;
wxPoint   * wxGaugewxGaugepos3;
wxSize  * wxGaugewxGaugesize4;
long  * wxGaugewxGaugestyle5;
wxValidator  * wxGaugewxGaugevalidator6;
wxString  * wxGaugewxGaugename7;
wxGauge * newwxGauge1 = new wxGauge( * wxGaugewxGaugeparent0,  * wxGaugewxGaugeid1,  * wxGaugewxGaugerange2,  * wxGaugewxGaugepos3,  * wxGaugewxGaugesize4,  * wxGaugewxGaugestyle5,  * wxGaugewxGaugevalidator6,  * wxGaugewxGaugename7);
// Looking at method wxGauge::Create
wxWindow*  * wxGaugeCreateparent0;
wxWindowID  * wxGaugeCreateid1;
int  * wxGaugeCreaterange2;
wxPoint   * wxGaugeCreatepos3;
wxSize  * wxGaugeCreatesize4;
long  * wxGaugeCreatestyle5;
wxValidator  * wxGaugeCreatevalidator6;
wxString  * wxGaugeCreatename7;
bool retwxGaugeCreate0 = mywxGauge->Create( * wxGaugeCreateparent0,  * wxGaugeCreateid1,  * wxGaugeCreaterange2,  * wxGaugeCreatepos3,  * wxGaugeCreatesize4,  * wxGaugeCreatestyle5,  * wxGaugeCreatevalidator6,  * wxGaugeCreatename7);
// Looking at method wxGauge::GetBezelFace
int retwxGaugeGetBezelFace0 = mywxGauge->GetBezelFace();
// Looking at method wxGauge::GetRange
int retwxGaugeGetRange0 = mywxGauge->GetRange();
// Looking at method wxGauge::GetShadowWidth
int retwxGaugeGetShadowWidth0 = mywxGauge->GetShadowWidth();
// Looking at method wxGauge::GetValue
int retwxGaugeGetValue0 = mywxGauge->GetValue();
// Looking at method wxGauge::IsVertical
bool retwxGaugeIsVertical0 = mywxGauge->IsVertical();
// Looking at method wxGauge::SetBezelFace
int  * wxGaugeSetBezelFacewidth0;
mywxGauge->SetBezelFace( * wxGaugeSetBezelFacewidth0);
// Looking at method wxGauge::SetRange
int  * wxGaugeSetRangerange0;
mywxGauge->SetRange( * wxGaugeSetRangerange0);
// Looking at method wxGauge::SetShadowWidth
int  * wxGaugeSetShadowWidthwidth0;
mywxGauge->SetShadowWidth( * wxGaugeSetShadowWidthwidth0);
// Looking at method wxGauge::SetValue
int  * wxGaugeSetValuepos0;
mywxGauge->SetValue( * wxGaugeSetValuepos0);

// Looking at class wxGenericDirCtrl
wxGenericDirCtrl * mywxGenericDirCtrl;
// Looking at method wxGenericDirCtrl::wxGenericDirCtrl
wxGenericDirCtrl * newwxGenericDirCtrl0 = new wxGenericDirCtrl();
wxWindow*  * wxGenericDirCtrlwxGenericDirCtrlparent0;
wxWindowID  * wxGenericDirCtrlwxGenericDirCtrlid1;
wxString  * wxGenericDirCtrlwxGenericDirCtrldir2;
wxPoint  * wxGenericDirCtrlwxGenericDirCtrlpos3;
wxSize  * wxGenericDirCtrlwxGenericDirCtrlsize4;
long  * wxGenericDirCtrlwxGenericDirCtrlstyle5;
wxString  * wxGenericDirCtrlwxGenericDirCtrlfilter6;
int  * wxGenericDirCtrlwxGenericDirCtrldefaultFilter7;
wxString  * wxGenericDirCtrlwxGenericDirCtrlname8;
wxGenericDirCtrl * newwxGenericDirCtrl1 = new wxGenericDirCtrl( * wxGenericDirCtrlwxGenericDirCtrlparent0,  * wxGenericDirCtrlwxGenericDirCtrlid1,  * wxGenericDirCtrlwxGenericDirCtrldir2,  * wxGenericDirCtrlwxGenericDirCtrlpos3,  * wxGenericDirCtrlwxGenericDirCtrlsize4,  * wxGenericDirCtrlwxGenericDirCtrlstyle5,  * wxGenericDirCtrlwxGenericDirCtrlfilter6,  * wxGenericDirCtrlwxGenericDirCtrldefaultFilter7,  * wxGenericDirCtrlwxGenericDirCtrlname8);
// Looking at method wxGenericDirCtrl::Create
wxWindow*  * wxGenericDirCtrlCreateparent0;
wxWindowID  * wxGenericDirCtrlCreateid1;
wxString  * wxGenericDirCtrlCreatedir2;
wxPoint  * wxGenericDirCtrlCreatepos3;
wxSize  * wxGenericDirCtrlCreatesize4;
long  * wxGenericDirCtrlCreatestyle5;
wxString  * wxGenericDirCtrlCreatefilter6;
int  * wxGenericDirCtrlCreatedefaultFilter7;
wxString  * wxGenericDirCtrlCreatename8;
bool retwxGenericDirCtrlCreate0 = mywxGenericDirCtrl->Create( * wxGenericDirCtrlCreateparent0,  * wxGenericDirCtrlCreateid1,  * wxGenericDirCtrlCreatedir2,  * wxGenericDirCtrlCreatepos3,  * wxGenericDirCtrlCreatesize4,  * wxGenericDirCtrlCreatestyle5,  * wxGenericDirCtrlCreatefilter6,  * wxGenericDirCtrlCreatedefaultFilter7,  * wxGenericDirCtrlCreatename8);
// Looking at method wxGenericDirCtrl::Init
mywxGenericDirCtrl->Init();
// Looking at method wxGenericDirCtrl::ExpandPath
wxString  * wxGenericDirCtrlExpandPathpath0;
bool retwxGenericDirCtrlExpandPath0 = mywxGenericDirCtrl->ExpandPath( * wxGenericDirCtrlExpandPathpath0);
// Looking at method wxGenericDirCtrl::GetDefaultPath
wxString retwxGenericDirCtrlGetDefaultPath0 = mywxGenericDirCtrl->GetDefaultPath();
// Looking at method wxGenericDirCtrl::GetPath
wxString retwxGenericDirCtrlGetPath0 = mywxGenericDirCtrl->GetPath();
// Looking at method wxGenericDirCtrl::GetFilePath
wxString retwxGenericDirCtrlGetFilePath0 = mywxGenericDirCtrl->GetFilePath();
// Looking at method wxGenericDirCtrl::GetFilter
wxString retwxGenericDirCtrlGetFilter0 = mywxGenericDirCtrl->GetFilter();
// Looking at method wxGenericDirCtrl::GetFilterIndex
int retwxGenericDirCtrlGetFilterIndex0 = mywxGenericDirCtrl->GetFilterIndex();
// Looking at method wxGenericDirCtrl::GetFilterListCtrl
wxDirFilterListCtrl* retwxGenericDirCtrlGetFilterListCtrl0 = mywxGenericDirCtrl->GetFilterListCtrl();
// Looking at method wxGenericDirCtrl::GetRootId
wxTreeItemId retwxGenericDirCtrlGetRootId0 = mywxGenericDirCtrl->GetRootId();
// Looking at method wxGenericDirCtrl::GetTreeCtrl
wxTreeCtrl* retwxGenericDirCtrlGetTreeCtrl0 = mywxGenericDirCtrl->GetTreeCtrl();
// Looking at method wxGenericDirCtrl::SetDefaultPath
wxString  * wxGenericDirCtrlSetDefaultPathpath0;
mywxGenericDirCtrl->SetDefaultPath( * wxGenericDirCtrlSetDefaultPathpath0);
// Looking at method wxGenericDirCtrl::SetFilter
wxString  * wxGenericDirCtrlSetFilterfilter0;
mywxGenericDirCtrl->SetFilter( * wxGenericDirCtrlSetFilterfilter0);
// Looking at method wxGenericDirCtrl::SetFilterIndex
int  * wxGenericDirCtrlSetFilterIndexn0;
mywxGenericDirCtrl->SetFilterIndex( * wxGenericDirCtrlSetFilterIndexn0);
// Looking at method wxGenericDirCtrl::SetPath
wxString  * wxGenericDirCtrlSetPathpath0;
mywxGenericDirCtrl->SetPath( * wxGenericDirCtrlSetPathpath0);

// Looking at class wxGenericValidator
wxGenericValidator * mywxGenericValidator;
// Looking at method wxGenericValidator::wxGenericValidator
wxGenericValidator  * wxGenericValidatorwxGenericValidatorvalidator0;
wxGenericValidator * newwxGenericValidator0 = new wxGenericValidator( * wxGenericValidatorwxGenericValidatorvalidator0);
bool*  * wxGenericValidatorwxGenericValidatorvalPtr1;
wxGenericValidator * newwxGenericValidator1 = new wxGenericValidator( * wxGenericValidatorwxGenericValidatorvalPtr1);
wxString*  * wxGenericValidatorwxGenericValidatorvalPtr2;
wxGenericValidator * newwxGenericValidator2 = new wxGenericValidator( * wxGenericValidatorwxGenericValidatorvalPtr2);
int*  * wxGenericValidatorwxGenericValidatorvalPtr3;
wxGenericValidator * newwxGenericValidator3 = new wxGenericValidator( * wxGenericValidatorwxGenericValidatorvalPtr3);
wxArrayInt*  * wxGenericValidatorwxGenericValidatorvalPtr4;
wxGenericValidator * newwxGenericValidator4 = new wxGenericValidator( * wxGenericValidatorwxGenericValidatorvalPtr4);
// Looking at method wxGenericValidator::Clone
// Looking at method wxGenericValidator::TransferFromWindow
// Looking at method wxGenericValidator::TransferToWindow

// Looking at class wxGrid
wxGrid * mywxGrid;

// Looking at class wxGridBagSizer
wxGridBagSizer * mywxGridBagSizer;
// Looking at method wxGridBagSizer::wxGridBagSizer
int  * wxGridBagSizerwxGridBagSizervgap0;
int  * wxGridBagSizerwxGridBagSizerhgap1;
wxGridBagSizer * newwxGridBagSizer0 = new wxGridBagSizer( * wxGridBagSizerwxGridBagSizervgap0,  * wxGridBagSizerwxGridBagSizerhgap1);
// Looking at method wxGridBagSizer::Add
wxWindow*  * wxGridBagSizerAddwindow0;
wxGBPosition  * wxGridBagSizerAddpos1;
wxGBSpan  * wxGridBagSizerAddspan2;
int  * wxGridBagSizerAddflag3;
int  * wxGridBagSizerAddborder4;
wxObject*  * wxGridBagSizerAdduserData5;
wxSizerItem* retwxGridBagSizerAdd0 = mywxGridBagSizer->Add( * wxGridBagSizerAddwindow0,  * wxGridBagSizerAddpos1,  * wxGridBagSizerAddspan2,  * wxGridBagSizerAddflag3,  * wxGridBagSizerAddborder4,  * wxGridBagSizerAdduserData5);
wxSizer*  * wxGridBagSizerAddsizer6;
wxGBPosition  * wxGridBagSizerAddpos7;
wxGBSpan  * wxGridBagSizerAddspan8;
int  * wxGridBagSizerAddflag9;
int  * wxGridBagSizerAddborder10;
wxObject*  * wxGridBagSizerAdduserData11;
wxSizerItem* retwxGridBagSizerAdd1 = mywxGridBagSizer->Add( * wxGridBagSizerAddsizer6,  * wxGridBagSizerAddpos7,  * wxGridBagSizerAddspan8,  * wxGridBagSizerAddflag9,  * wxGridBagSizerAddborder10,  * wxGridBagSizerAdduserData11);
int  * wxGridBagSizerAddwidth12;
int  * wxGridBagSizerAddheight13;
wxGBPosition  * wxGridBagSizerAddpos14;
wxGBSpan  * wxGridBagSizerAddspan15;
int  * wxGridBagSizerAddflag16;
int  * wxGridBagSizerAddborder17;
wxObject*  * wxGridBagSizerAdduserData18;
wxSizerItem* retwxGridBagSizerAdd2 = mywxGridBagSizer->Add( * wxGridBagSizerAddwidth12,  * wxGridBagSizerAddheight13,  * wxGridBagSizerAddpos14,  * wxGridBagSizerAddspan15,  * wxGridBagSizerAddflag16,  * wxGridBagSizerAddborder17,  * wxGridBagSizerAdduserData18);
wxGBSizerItem*  * wxGridBagSizerAdditem19;
wxSizerItem* retwxGridBagSizerAdd3 = mywxGridBagSizer->Add( * wxGridBagSizerAdditem19);
// Looking at method wxGridBagSizer::CalcMin
wxSize retwxGridBagSizerCalcMin0 = mywxGridBagSizer->CalcMin();
// Looking at method wxGridBagSizer::CheckForIntersection
wxGBSizerItem*  * wxGridBagSizerCheckForIntersectionitem0;
wxGBSizerItem*  * wxGridBagSizerCheckForIntersectionexcludeItem1;
bool retwxGridBagSizerCheckForIntersection0 = mywxGridBagSizer->CheckForIntersection( * wxGridBagSizerCheckForIntersectionitem0,  * wxGridBagSizerCheckForIntersectionexcludeItem1);
wxGBPosition  * wxGridBagSizerCheckForIntersectionpos2;
wxGBSpan  * wxGridBagSizerCheckForIntersectionspan3;
wxGBSizerItem*  * wxGridBagSizerCheckForIntersectionexcludeItem4;
bool retwxGridBagSizerCheckForIntersection1 = mywxGridBagSizer->CheckForIntersection( * wxGridBagSizerCheckForIntersectionpos2,  * wxGridBagSizerCheckForIntersectionspan3,  * wxGridBagSizerCheckForIntersectionexcludeItem4);
// Looking at method wxGridBagSizer::FindItem
wxWindow*  * wxGridBagSizerFindItemwindow0;
wxGBSizerItem* retwxGridBagSizerFindItem0 = mywxGridBagSizer->FindItem( * wxGridBagSizerFindItemwindow0);
wxSizer*  * wxGridBagSizerFindItemsizer1;
wxGBSizerItem* retwxGridBagSizerFindItem1 = mywxGridBagSizer->FindItem( * wxGridBagSizerFindItemsizer1);
// Looking at method wxGridBagSizer::FindItemAtPoint
wxPoint  * wxGridBagSizerFindItemAtPointpt0;
wxGBSizerItem* retwxGridBagSizerFindItemAtPoint0 = mywxGridBagSizer->FindItemAtPoint( * wxGridBagSizerFindItemAtPointpt0);
// Looking at method wxGridBagSizer::FindItemAtPosition
wxGBPosition  * wxGridBagSizerFindItemAtPositionpos0;
wxGBSizerItem* retwxGridBagSizerFindItemAtPosition0 = mywxGridBagSizer->FindItemAtPosition( * wxGridBagSizerFindItemAtPositionpos0);
// Looking at method wxGridBagSizer::FindItemWithData
wxObject*  * wxGridBagSizerFindItemWithDatauserData0;
wxGBSizerItem* retwxGridBagSizerFindItemWithData0 = mywxGridBagSizer->FindItemWithData( * wxGridBagSizerFindItemWithDatauserData0);
// Looking at method wxGridBagSizer::GetCellSize
int  * wxGridBagSizerGetCellSizerow0;
int  * wxGridBagSizerGetCellSizecol1;
wxSize retwxGridBagSizerGetCellSize0 = mywxGridBagSizer->GetCellSize( * wxGridBagSizerGetCellSizerow0,  * wxGridBagSizerGetCellSizecol1);
// Looking at method wxGridBagSizer::GetEmptyCellSize
wxSize retwxGridBagSizerGetEmptyCellSize0 = mywxGridBagSizer->GetEmptyCellSize();
// Looking at method wxGridBagSizer::GetItemPosition
wxWindow*  * wxGridBagSizerGetItemPositionwindow0;
wxGBPosition retwxGridBagSizerGetItemPosition0 = mywxGridBagSizer->GetItemPosition( * wxGridBagSizerGetItemPositionwindow0);
wxSizer*  * wxGridBagSizerGetItemPositionsizer1;
wxGBPosition retwxGridBagSizerGetItemPosition1 = mywxGridBagSizer->GetItemPosition( * wxGridBagSizerGetItemPositionsizer1);
size_t  * wxGridBagSizerGetItemPositionindex2;
wxGBPosition retwxGridBagSizerGetItemPosition2 = mywxGridBagSizer->GetItemPosition( * wxGridBagSizerGetItemPositionindex2);
// Looking at method wxGridBagSizer::GetItemSpan
wxWindow*  * wxGridBagSizerGetItemSpanwindow0;
wxGBSpan retwxGridBagSizerGetItemSpan0 = mywxGridBagSizer->GetItemSpan( * wxGridBagSizerGetItemSpanwindow0);
wxSizer*  * wxGridBagSizerGetItemSpansizer1;
wxGBSpan retwxGridBagSizerGetItemSpan1 = mywxGridBagSizer->GetItemSpan( * wxGridBagSizerGetItemSpansizer1);
size_t  * wxGridBagSizerGetItemSpanindex2;
wxGBSpan retwxGridBagSizerGetItemSpan2 = mywxGridBagSizer->GetItemSpan( * wxGridBagSizerGetItemSpanindex2);
// Looking at method wxGridBagSizer::RecalcSizes
mywxGridBagSizer->RecalcSizes();
// Looking at method wxGridBagSizer::SetEmptyCellSize
wxSize  * wxGridBagSizerSetEmptyCellSizesz0;
mywxGridBagSizer->SetEmptyCellSize( * wxGridBagSizerSetEmptyCellSizesz0);
// Looking at method wxGridBagSizer::SetItemPosition
wxWindow*  * wxGridBagSizerSetItemPositionwindow0;
wxGBPosition  * wxGridBagSizerSetItemPositionpos1;
bool retwxGridBagSizerSetItemPosition0 = mywxGridBagSizer->SetItemPosition( * wxGridBagSizerSetItemPositionwindow0,  * wxGridBagSizerSetItemPositionpos1);
wxSizer*  * wxGridBagSizerSetItemPositionsizer2;
wxGBPosition  * wxGridBagSizerSetItemPositionpos3;
bool retwxGridBagSizerSetItemPosition1 = mywxGridBagSizer->SetItemPosition( * wxGridBagSizerSetItemPositionsizer2,  * wxGridBagSizerSetItemPositionpos3);
size_t  * wxGridBagSizerSetItemPositionindex4;
wxGBPosition  * wxGridBagSizerSetItemPositionpos5;
bool retwxGridBagSizerSetItemPosition2 = mywxGridBagSizer->SetItemPosition( * wxGridBagSizerSetItemPositionindex4,  * wxGridBagSizerSetItemPositionpos5);
// Looking at method wxGridBagSizer::SetItemSpan
wxWindow*  * wxGridBagSizerSetItemSpanwindow0;
wxGBSpan  * wxGridBagSizerSetItemSpanspan1;
bool retwxGridBagSizerSetItemSpan0 = mywxGridBagSizer->SetItemSpan( * wxGridBagSizerSetItemSpanwindow0,  * wxGridBagSizerSetItemSpanspan1);
wxSizer*  * wxGridBagSizerSetItemSpansizer2;
wxGBSpan  * wxGridBagSizerSetItemSpanspan3;
bool retwxGridBagSizerSetItemSpan1 = mywxGridBagSizer->SetItemSpan( * wxGridBagSizerSetItemSpansizer2,  * wxGridBagSizerSetItemSpanspan3);
size_t  * wxGridBagSizerSetItemSpanindex4;
wxGBSpan  * wxGridBagSizerSetItemSpanspan5;
bool retwxGridBagSizerSetItemSpan2 = mywxGridBagSizer->SetItemSpan( * wxGridBagSizerSetItemSpanindex4,  * wxGridBagSizerSetItemSpanspan5);

// Looking at class wxGridCellAttr
wxGridCellAttr * mywxGridCellAttr;
// Looking at method wxGridCellAttr::wxGridCellAttr
wxGridCellAttr * newwxGridCellAttr0 = new wxGridCellAttr();
wxColour  * wxGridCellAttrwxGridCellAttrcolText0;
wxColour  * wxGridCellAttrwxGridCellAttrcolBack1;
wxFont  * wxGridCellAttrwxGridCellAttrfont2;
int  * wxGridCellAttrwxGridCellAttrhAlign3;
int  * wxGridCellAttrwxGridCellAttrvAlign4;
wxGridCellAttr * newwxGridCellAttr1 = new wxGridCellAttr( * wxGridCellAttrwxGridCellAttrcolText0,  * wxGridCellAttrwxGridCellAttrcolBack1,  * wxGridCellAttrwxGridCellAttrfont2,  * wxGridCellAttrwxGridCellAttrhAlign3,  * wxGridCellAttrwxGridCellAttrvAlign4);
// Looking at method wxGridCellAttr::Clone
wxGridCellAttr* retwxGridCellAttrClone0 = mywxGridCellAttr->Clone();
// Looking at method wxGridCellAttr::IncRef
mywxGridCellAttr->IncRef();
// Looking at method wxGridCellAttr::DecRef
mywxGridCellAttr->DecRef();
// Looking at method wxGridCellAttr::SetTextColour
wxColour  * wxGridCellAttrSetTextColourcolText0;
mywxGridCellAttr->SetTextColour( * wxGridCellAttrSetTextColourcolText0);
// Looking at method wxGridCellAttr::SetBackgroundColour
wxColour  * wxGridCellAttrSetBackgroundColourcolBack0;
mywxGridCellAttr->SetBackgroundColour( * wxGridCellAttrSetBackgroundColourcolBack0);
// Looking at method wxGridCellAttr::SetFont
wxFont  * wxGridCellAttrSetFontfont0;
mywxGridCellAttr->SetFont( * wxGridCellAttrSetFontfont0);
// Looking at method wxGridCellAttr::SetAlignment
int  * wxGridCellAttrSetAlignmenthAlign0;
int  * wxGridCellAttrSetAlignmentvAlign1;
mywxGridCellAttr->SetAlignment( * wxGridCellAttrSetAlignmenthAlign0,  * wxGridCellAttrSetAlignmentvAlign1);
// Looking at method wxGridCellAttr::SetReadOnly
bool  * wxGridCellAttrSetReadOnlyisReadOnly0;
mywxGridCellAttr->SetReadOnly( * wxGridCellAttrSetReadOnlyisReadOnly0);
// Looking at method wxGridCellAttr::SetRenderer
wxGridCellRenderer*  * wxGridCellAttrSetRendererrenderer0;
mywxGridCellAttr->SetRenderer( * wxGridCellAttrSetRendererrenderer0);
// Looking at method wxGridCellAttr::SetEditor
wxGridCellEditor*  * wxGridCellAttrSetEditoreditor0;
mywxGridCellAttr->SetEditor( * wxGridCellAttrSetEditoreditor0);
// Looking at method wxGridCellAttr::HasTextColour
bool retwxGridCellAttrHasTextColour0 = mywxGridCellAttr->HasTextColour();
// Looking at method wxGridCellAttr::HasBackgroundColour
bool retwxGridCellAttrHasBackgroundColour0 = mywxGridCellAttr->HasBackgroundColour();
// Looking at method wxGridCellAttr::HasFont
bool retwxGridCellAttrHasFont0 = mywxGridCellAttr->HasFont();
// Looking at method wxGridCellAttr::HasAlignment
bool retwxGridCellAttrHasAlignment0 = mywxGridCellAttr->HasAlignment();
// Looking at method wxGridCellAttr::HasRenderer
bool retwxGridCellAttrHasRenderer0 = mywxGridCellAttr->HasRenderer();
// Looking at method wxGridCellAttr::HasEditor
bool retwxGridCellAttrHasEditor0 = mywxGridCellAttr->HasEditor();
// Looking at method wxGridCellAttr::GetTextColour
const wxColour retwxGridCellAttrGetTextColour0 = mywxGridCellAttr->GetTextColour();
// Looking at method wxGridCellAttr::GetBackgroundColour
const wxColour retwxGridCellAttrGetBackgroundColour0 = mywxGridCellAttr->GetBackgroundColour();
// Looking at method wxGridCellAttr::GetFont
const wxFont retwxGridCellAttrGetFont0 = mywxGridCellAttr->GetFont();
// Looking at method wxGridCellAttr::GetAlignment
int*  * wxGridCellAttrGetAlignmenthAlign0;
int*  * wxGridCellAttrGetAlignmentvAlign1;
mywxGridCellAttr->GetAlignment( * wxGridCellAttrGetAlignmenthAlign0,  * wxGridCellAttrGetAlignmentvAlign1);
// Looking at method wxGridCellAttr::GetRenderer
wxGrid*  * wxGridCellAttrGetRenderergrid0;
int  * wxGridCellAttrGetRendererrow1;
int  * wxGridCellAttrGetRenderercol2;
wxGridCellRenderer* retwxGridCellAttrGetRenderer0 = mywxGridCellAttr->GetRenderer( * wxGridCellAttrGetRenderergrid0,  * wxGridCellAttrGetRendererrow1,  * wxGridCellAttrGetRenderercol2);
// Looking at method wxGridCellAttr::GetEditor
wxGrid*  * wxGridCellAttrGetEditorgrid0;
int  * wxGridCellAttrGetEditorrow1;
int  * wxGridCellAttrGetEditorcol2;
wxGridCellEditor* retwxGridCellAttrGetEditor0 = mywxGridCellAttr->GetEditor( * wxGridCellAttrGetEditorgrid0,  * wxGridCellAttrGetEditorrow1,  * wxGridCellAttrGetEditorcol2);
// Looking at method wxGridCellAttr::IsReadOnly
bool retwxGridCellAttrIsReadOnly0 = mywxGridCellAttr->IsReadOnly();
// Looking at method wxGridCellAttr::SetDefAttr
wxGridCellAttr*  * wxGridCellAttrSetDefAttrdefAttr0;
mywxGridCellAttr->SetDefAttr( * wxGridCellAttrSetDefAttrdefAttr0);

// Looking at class wxGridCellBoolEditor
wxGridCellBoolEditor * mywxGridCellBoolEditor;
// Looking at method wxGridCellBoolEditor::wxGridCellBoolEditor
wxGridCellBoolEditor * newwxGridCellBoolEditor0 = new wxGridCellBoolEditor();

// Looking at class wxGridCellBoolRenderer
wxGridCellBoolRenderer * mywxGridCellBoolRenderer;
// Looking at method wxGridCellBoolRenderer::wxGridCellBoolRenderer
wxGridCellBoolRenderer * newwxGridCellBoolRenderer0 = new wxGridCellBoolRenderer();

// Looking at class wxGridCellChoiceEditor
wxGridCellChoiceEditor * mywxGridCellChoiceEditor;
// Looking at method wxGridCellChoiceEditor::wxGridCellChoiceEditor
size_t  * wxGridCellChoiceEditorwxGridCellChoiceEditorcount0;
wxString  * * wxGridCellChoiceEditorwxGridCellChoiceEditorchoicesptr1;
bool  * wxGridCellChoiceEditorwxGridCellChoiceEditorallowOthers2;
wxGridCellChoiceEditor * newwxGridCellChoiceEditor0 = new wxGridCellChoiceEditor( * wxGridCellChoiceEditorwxGridCellChoiceEditorcount0,  * wxGridCellChoiceEditorwxGridCellChoiceEditorchoicesptr1,  * wxGridCellChoiceEditorwxGridCellChoiceEditorallowOthers2);
wxArrayString  * wxGridCellChoiceEditorwxGridCellChoiceEditorchoices3;
bool  * wxGridCellChoiceEditorwxGridCellChoiceEditorallowOthers4;
wxGridCellChoiceEditor * newwxGridCellChoiceEditor1 = new wxGridCellChoiceEditor( * wxGridCellChoiceEditorwxGridCellChoiceEditorchoices3,  * wxGridCellChoiceEditorwxGridCellChoiceEditorallowOthers4);
// Looking at method wxGridCellChoiceEditor::SetParameters
wxString  * wxGridCellChoiceEditorSetParametersparams0;
mywxGridCellChoiceEditor->SetParameters( * wxGridCellChoiceEditorSetParametersparams0);

// Looking at class wxGridCellFloatEditor
wxGridCellFloatEditor * mywxGridCellFloatEditor;
// Looking at method wxGridCellFloatEditor::wxGridCellFloatEditor
int  * wxGridCellFloatEditorwxGridCellFloatEditorwidth0;
int  * wxGridCellFloatEditorwxGridCellFloatEditorprecision1;
wxGridCellFloatEditor * newwxGridCellFloatEditor0 = new wxGridCellFloatEditor( * wxGridCellFloatEditorwxGridCellFloatEditorwidth0,  * wxGridCellFloatEditorwxGridCellFloatEditorprecision1);
// Looking at method wxGridCellFloatEditor::SetParameters
wxString  * wxGridCellFloatEditorSetParametersparams0;
mywxGridCellFloatEditor->SetParameters( * wxGridCellFloatEditorSetParametersparams0);

// Looking at class wxGridCellFloatRenderer
wxGridCellFloatRenderer * mywxGridCellFloatRenderer;
// Looking at method wxGridCellFloatRenderer::wxGridCellFloatRenderer
int  * wxGridCellFloatRendererwxGridCellFloatRendererwidth0;
int  * wxGridCellFloatRendererwxGridCellFloatRendererprecision1;
wxGridCellFloatRenderer * newwxGridCellFloatRenderer0 = new wxGridCellFloatRenderer( * wxGridCellFloatRendererwxGridCellFloatRendererwidth0,  * wxGridCellFloatRendererwxGridCellFloatRendererprecision1);
// Looking at method wxGridCellFloatRenderer::GetPrecision
int retwxGridCellFloatRendererGetPrecision0 = mywxGridCellFloatRenderer->GetPrecision();
// Looking at method wxGridCellFloatRenderer::GetWidth
int retwxGridCellFloatRendererGetWidth0 = mywxGridCellFloatRenderer->GetWidth();
// Looking at method wxGridCellFloatRenderer::SetParameters
wxString  * wxGridCellFloatRendererSetParametersparams0;
mywxGridCellFloatRenderer->SetParameters( * wxGridCellFloatRendererSetParametersparams0);
// Looking at method wxGridCellFloatRenderer::SetPrecision
int  * wxGridCellFloatRendererSetPrecisionprecision0;
mywxGridCellFloatRenderer->SetPrecision( * wxGridCellFloatRendererSetPrecisionprecision0);
// Looking at method wxGridCellFloatRenderer::SetWidth
int  * wxGridCellFloatRendererSetWidthwidth0;
mywxGridCellFloatRenderer->SetWidth( * wxGridCellFloatRendererSetWidthwidth0);

// Looking at class wxGridCellNumberRenderer
wxGridCellNumberRenderer * mywxGridCellNumberRenderer;
// Looking at method wxGridCellNumberRenderer::wxGridCellNumberRenderer
wxGridCellNumberRenderer * newwxGridCellNumberRenderer0 = new wxGridCellNumberRenderer();

// Looking at class wxGridCellRenderer
wxGridCellRenderer * mywxGridCellRenderer;
// Looking at method wxGridCellRenderer::Draw
wxGrid  * wxGridCellRendererDrawgrid0;
wxGridCellAttr  * wxGridCellRendererDrawattr1;
wxDC  * wxGridCellRendererDrawdc2;
wxRect  * wxGridCellRendererDrawrect3;
int  * wxGridCellRendererDrawrow4;
int  * wxGridCellRendererDrawcol5;
bool  * wxGridCellRendererDrawisSelected6;
mywxGridCellRenderer->Draw( * wxGridCellRendererDrawgrid0,  * wxGridCellRendererDrawattr1,  * wxGridCellRendererDrawdc2,  * wxGridCellRendererDrawrect3,  * wxGridCellRendererDrawrow4,  * wxGridCellRendererDrawcol5,  * wxGridCellRendererDrawisSelected6);
// Looking at method wxGridCellRenderer::GetBestSize
wxGrid  * wxGridCellRendererGetBestSizegrid0;
wxGridCellAttr  * wxGridCellRendererGetBestSizeattr1;
wxDC  * wxGridCellRendererGetBestSizedc2;
int  * wxGridCellRendererGetBestSizerow3;
int  * wxGridCellRendererGetBestSizecol4;
wxSize retwxGridCellRendererGetBestSize0 = mywxGridCellRenderer->GetBestSize( * wxGridCellRendererGetBestSizegrid0,  * wxGridCellRendererGetBestSizeattr1,  * wxGridCellRendererGetBestSizedc2,  * wxGridCellRendererGetBestSizerow3,  * wxGridCellRendererGetBestSizecol4);
// Looking at method wxGridCellRenderer::Clone
wxGridCellRenderer* retwxGridCellRendererClone0 = mywxGridCellRenderer->Clone();

// Looking at class wxGridCellStringRenderer
wxGridCellStringRenderer * mywxGridCellStringRenderer;
// Looking at method wxGridCellStringRenderer::wxGridCellStringRenderer
wxGridCellStringRenderer * newwxGridCellStringRenderer0 = new wxGridCellStringRenderer();

// Looking at class wxGridCellTextEditor
wxGridCellTextEditor * mywxGridCellTextEditor;
// Looking at method wxGridCellTextEditor::wxGridCellTextEditor
wxGridCellTextEditor * newwxGridCellTextEditor0 = new wxGridCellTextEditor();
// Looking at method wxGridCellTextEditor::SetParameters
wxString  * wxGridCellTextEditorSetParametersparams0;
mywxGridCellTextEditor->SetParameters( * wxGridCellTextEditorSetParametersparams0);

// Looking at class wxGridEditorCreatedEvent
wxGridEditorCreatedEvent * mywxGridEditorCreatedEvent;
// Looking at method wxGridEditorCreatedEvent::wxGridEditorCreatedEvent
wxGridEditorCreatedEvent * newwxGridEditorCreatedEvent0 = new wxGridEditorCreatedEvent();
int  * wxGridEditorCreatedEventwxGridEditorCreatedEventid0;
wxEventType  * wxGridEditorCreatedEventwxGridEditorCreatedEventtype1;
wxObject*  * wxGridEditorCreatedEventwxGridEditorCreatedEventobj2;
int  * wxGridEditorCreatedEventwxGridEditorCreatedEventrow3;
int  * wxGridEditorCreatedEventwxGridEditorCreatedEventcol4;
wxControl*  * wxGridEditorCreatedEventwxGridEditorCreatedEventctrl5;
wxGridEditorCreatedEvent * newwxGridEditorCreatedEvent1 = new wxGridEditorCreatedEvent( * wxGridEditorCreatedEventwxGridEditorCreatedEventid0,  * wxGridEditorCreatedEventwxGridEditorCreatedEventtype1,  * wxGridEditorCreatedEventwxGridEditorCreatedEventobj2,  * wxGridEditorCreatedEventwxGridEditorCreatedEventrow3,  * wxGridEditorCreatedEventwxGridEditorCreatedEventcol4,  * wxGridEditorCreatedEventwxGridEditorCreatedEventctrl5);
// Looking at method wxGridEditorCreatedEvent::GetCol
int retwxGridEditorCreatedEventGetCol0 = mywxGridEditorCreatedEvent->GetCol();
// Looking at method wxGridEditorCreatedEvent::GetControl
wxControl* retwxGridEditorCreatedEventGetControl0 = mywxGridEditorCreatedEvent->GetControl();
// Looking at method wxGridEditorCreatedEvent::GetRow
int retwxGridEditorCreatedEventGetRow0 = mywxGridEditorCreatedEvent->GetRow();
// Looking at method wxGridEditorCreatedEvent::SetCol
int  * wxGridEditorCreatedEventSetColcol0;
mywxGridEditorCreatedEvent->SetCol( * wxGridEditorCreatedEventSetColcol0);
// Looking at method wxGridEditorCreatedEvent::SetControl
wxControl*  * wxGridEditorCreatedEventSetControlctrl0;
mywxGridEditorCreatedEvent->SetControl( * wxGridEditorCreatedEventSetControlctrl0);
// Looking at method wxGridEditorCreatedEvent::SetRow
int  * wxGridEditorCreatedEventSetRowrow0;
mywxGridEditorCreatedEvent->SetRow( * wxGridEditorCreatedEventSetRowrow0);

// Looking at class wxGridEvent
wxGridEvent * mywxGridEvent;
// Looking at method wxGridEvent::wxGridEvent
wxGridEvent * newwxGridEvent0 = new wxGridEvent();
int  * wxGridEventwxGridEventid0;
wxEventType  * wxGridEventwxGridEventtype1;
wxObject*  * wxGridEventwxGridEventobj2;
int  * wxGridEventwxGridEventrow3;
int  * wxGridEventwxGridEventcol4;
int  * wxGridEventwxGridEventx5;
int  * wxGridEventwxGridEventy6;
bool  * wxGridEventwxGridEventsel7;
bool  * wxGridEventwxGridEventcontrol8;
bool  * wxGridEventwxGridEventshift9;
bool  * wxGridEventwxGridEventalt10;
bool  * wxGridEventwxGridEventmeta11;
wxGridEvent * newwxGridEvent1 = new wxGridEvent( * wxGridEventwxGridEventid0,  * wxGridEventwxGridEventtype1,  * wxGridEventwxGridEventobj2,  * wxGridEventwxGridEventrow3,  * wxGridEventwxGridEventcol4,  * wxGridEventwxGridEventx5,  * wxGridEventwxGridEventy6,  * wxGridEventwxGridEventsel7,  * wxGridEventwxGridEventcontrol8,  * wxGridEventwxGridEventshift9,  * wxGridEventwxGridEventalt10,  * wxGridEventwxGridEventmeta11);
// Looking at method wxGridEvent::AltDown
bool retwxGridEventAltDown0 = mywxGridEvent->AltDown();
// Looking at method wxGridEvent::ControlDown
bool retwxGridEventControlDown0 = mywxGridEvent->ControlDown();
// Looking at method wxGridEvent::GetCol
int retwxGridEventGetCol0 = mywxGridEvent->GetCol();
// Looking at method wxGridEvent::GetPosition
wxPoint retwxGridEventGetPosition0 = mywxGridEvent->GetPosition();
// Looking at method wxGridEvent::GetRow
int retwxGridEventGetRow0 = mywxGridEvent->GetRow();
// Looking at method wxGridEvent::MetaDown
bool retwxGridEventMetaDown0 = mywxGridEvent->MetaDown();
// Looking at method wxGridEvent::Selecting
bool retwxGridEventSelecting0 = mywxGridEvent->Selecting();
// Looking at method wxGridEvent::ShiftDown
bool retwxGridEventShiftDown0 = mywxGridEvent->ShiftDown();

// Looking at class wxGridRangeSelectEvent
wxGridRangeSelectEvent * mywxGridRangeSelectEvent;
// Looking at method wxGridRangeSelectEvent::wxGridRangeSelectEvent
wxGridRangeSelectEvent * newwxGridRangeSelectEvent0 = new wxGridRangeSelectEvent();
int  * wxGridRangeSelectEventwxGridRangeSelectEventid0;
wxEventType  * wxGridRangeSelectEventwxGridRangeSelectEventtype1;
wxObject*  * wxGridRangeSelectEventwxGridRangeSelectEventobj2;
wxGridCellCoords  * wxGridRangeSelectEventwxGridRangeSelectEventtopLeft3;
wxGridCellCoords  * wxGridRangeSelectEventwxGridRangeSelectEventbottomRight4;
bool  * wxGridRangeSelectEventwxGridRangeSelectEventsel5;
bool  * wxGridRangeSelectEventwxGridRangeSelectEventcontrol6;
bool  * wxGridRangeSelectEventwxGridRangeSelectEventshift7;
bool  * wxGridRangeSelectEventwxGridRangeSelectEventalt8;
bool  * wxGridRangeSelectEventwxGridRangeSelectEventmeta9;
wxGridRangeSelectEvent * newwxGridRangeSelectEvent1 = new wxGridRangeSelectEvent( * wxGridRangeSelectEventwxGridRangeSelectEventid0,  * wxGridRangeSelectEventwxGridRangeSelectEventtype1,  * wxGridRangeSelectEventwxGridRangeSelectEventobj2,  * wxGridRangeSelectEventwxGridRangeSelectEventtopLeft3,  * wxGridRangeSelectEventwxGridRangeSelectEventbottomRight4,  * wxGridRangeSelectEventwxGridRangeSelectEventsel5,  * wxGridRangeSelectEventwxGridRangeSelectEventcontrol6,  * wxGridRangeSelectEventwxGridRangeSelectEventshift7,  * wxGridRangeSelectEventwxGridRangeSelectEventalt8,  * wxGridRangeSelectEventwxGridRangeSelectEventmeta9);
// Looking at method wxGridRangeSelectEvent::AltDown
bool retwxGridRangeSelectEventAltDown0 = mywxGridRangeSelectEvent->AltDown();
// Looking at method wxGridRangeSelectEvent::ControlDown
bool retwxGridRangeSelectEventControlDown0 = mywxGridRangeSelectEvent->ControlDown();
// Looking at method wxGridRangeSelectEvent::GetBottomRightCoords
wxGridCellCoords retwxGridRangeSelectEventGetBottomRightCoords0 = mywxGridRangeSelectEvent->GetBottomRightCoords();
// Looking at method wxGridRangeSelectEvent::GetBottomRow
int retwxGridRangeSelectEventGetBottomRow0 = mywxGridRangeSelectEvent->GetBottomRow();
// Looking at method wxGridRangeSelectEvent::GetLeftCol
int retwxGridRangeSelectEventGetLeftCol0 = mywxGridRangeSelectEvent->GetLeftCol();
// Looking at method wxGridRangeSelectEvent::GetRightCol
int retwxGridRangeSelectEventGetRightCol0 = mywxGridRangeSelectEvent->GetRightCol();
// Looking at method wxGridRangeSelectEvent::GetTopLeftCoords
wxGridCellCoords retwxGridRangeSelectEventGetTopLeftCoords0 = mywxGridRangeSelectEvent->GetTopLeftCoords();
// Looking at method wxGridRangeSelectEvent::GetTopRow
int retwxGridRangeSelectEventGetTopRow0 = mywxGridRangeSelectEvent->GetTopRow();
// Looking at method wxGridRangeSelectEvent::MetaDown
bool retwxGridRangeSelectEventMetaDown0 = mywxGridRangeSelectEvent->MetaDown();
// Looking at method wxGridRangeSelectEvent::Selecting
bool retwxGridRangeSelectEventSelecting0 = mywxGridRangeSelectEvent->Selecting();
// Looking at method wxGridRangeSelectEvent::ShiftDown
bool retwxGridRangeSelectEventShiftDown0 = mywxGridRangeSelectEvent->ShiftDown();

// Looking at class wxGridSizeEvent
wxGridSizeEvent * mywxGridSizeEvent;
// Looking at method wxGridSizeEvent::wxGridSizeEvent
wxGridSizeEvent * newwxGridSizeEvent0 = new wxGridSizeEvent();
int  * wxGridSizeEventwxGridSizeEventid0;
wxEventType  * wxGridSizeEventwxGridSizeEventtype1;
wxObject*  * wxGridSizeEventwxGridSizeEventobj2;
int  * wxGridSizeEventwxGridSizeEventrowOrCol3;
int  * wxGridSizeEventwxGridSizeEventx4;
int  * wxGridSizeEventwxGridSizeEventy5;
bool  * wxGridSizeEventwxGridSizeEventcontrol6;
bool  * wxGridSizeEventwxGridSizeEventshift7;
bool  * wxGridSizeEventwxGridSizeEventalt8;
bool  * wxGridSizeEventwxGridSizeEventmeta9;
wxGridSizeEvent * newwxGridSizeEvent1 = new wxGridSizeEvent( * wxGridSizeEventwxGridSizeEventid0,  * wxGridSizeEventwxGridSizeEventtype1,  * wxGridSizeEventwxGridSizeEventobj2,  * wxGridSizeEventwxGridSizeEventrowOrCol3,  * wxGridSizeEventwxGridSizeEventx4,  * wxGridSizeEventwxGridSizeEventy5,  * wxGridSizeEventwxGridSizeEventcontrol6,  * wxGridSizeEventwxGridSizeEventshift7,  * wxGridSizeEventwxGridSizeEventalt8,  * wxGridSizeEventwxGridSizeEventmeta9);
// Looking at method wxGridSizeEvent::AltDown
bool retwxGridSizeEventAltDown0 = mywxGridSizeEvent->AltDown();
// Looking at method wxGridSizeEvent::ControlDown
bool retwxGridSizeEventControlDown0 = mywxGridSizeEvent->ControlDown();
// Looking at method wxGridSizeEvent::GetPosition
wxPoint retwxGridSizeEventGetPosition0 = mywxGridSizeEvent->GetPosition();
// Looking at method wxGridSizeEvent::GetRowOrCol
int retwxGridSizeEventGetRowOrCol0 = mywxGridSizeEvent->GetRowOrCol();
// Looking at method wxGridSizeEvent::MetaDown
bool retwxGridSizeEventMetaDown0 = mywxGridSizeEvent->MetaDown();
// Looking at method wxGridSizeEvent::ShiftDown
bool retwxGridSizeEventShiftDown0 = mywxGridSizeEvent->ShiftDown();

// Looking at class wxGridSizer
wxGridSizer * mywxGridSizer;
// Looking at method wxGridSizer::wxGridSizer
int  * wxGridSizerwxGridSizerrows0;
int  * wxGridSizerwxGridSizercols1;
int  * wxGridSizerwxGridSizervgap2;
int  * wxGridSizerwxGridSizerhgap3;
wxGridSizer * newwxGridSizer0 = new wxGridSizer( * wxGridSizerwxGridSizerrows0,  * wxGridSizerwxGridSizercols1,  * wxGridSizerwxGridSizervgap2,  * wxGridSizerwxGridSizerhgap3);
int  * wxGridSizerwxGridSizercols4;
int  * wxGridSizerwxGridSizervgap5;
int  * wxGridSizerwxGridSizerhgap6;
wxGridSizer * newwxGridSizer1 = new wxGridSizer( * wxGridSizerwxGridSizercols4,  * wxGridSizerwxGridSizervgap5,  * wxGridSizerwxGridSizerhgap6);
// Looking at method wxGridSizer::GetCols
int retwxGridSizerGetCols0 = mywxGridSizer->GetCols();
// Looking at method wxGridSizer::GetHGap
int retwxGridSizerGetHGap0 = mywxGridSizer->GetHGap();
// Looking at method wxGridSizer::GetRows
int retwxGridSizerGetRows0 = mywxGridSizer->GetRows();
// Looking at method wxGridSizer::GetVGap
int retwxGridSizerGetVGap0 = mywxGridSizer->GetVGap();
// Looking at method wxGridSizer::SetCols
int  * wxGridSizerSetColscols0;
mywxGridSizer->SetCols( * wxGridSizerSetColscols0);
// Looking at method wxGridSizer::SetHGap
int  * wxGridSizerSetHGapgap0;
mywxGridSizer->SetHGap( * wxGridSizerSetHGapgap0);
// Looking at method wxGridSizer::SetRows
int  * wxGridSizerSetRowsrows0;
mywxGridSizer->SetRows( * wxGridSizerSetRowsrows0);
// Looking at method wxGridSizer::SetVGap
int  * wxGridSizerSetVGapgap0;
mywxGridSizer->SetVGap( * wxGridSizerSetVGapgap0);

// Looking at class wxHTTP
wxHTTP * mywxHTTP;
// Looking at method wxHTTP::GetResponse
int retwxHTTPGetResponse0 = mywxHTTP->GetResponse();
// Looking at method wxHTTP::GetInputStream
wxString  * wxHTTPGetInputStreampath0;
wxInputStream * retwxHTTPGetInputStream0 = mywxHTTP->GetInputStream( * wxHTTPGetInputStreampath0);
// Looking at method wxHTTP::SetHeader
wxString  * wxHTTPSetHeaderheader0;
wxString  * wxHTTPSetHeaderh_data1;
mywxHTTP->SetHeader( * wxHTTPSetHeaderheader0,  * wxHTTPSetHeaderh_data1);
// Looking at method wxHTTP::GetHeader
wxString  * wxHTTPGetHeaderheader0;
wxString retwxHTTPGetHeader0 = mywxHTTP->GetHeader( * wxHTTPGetHeaderheader0);

// Looking at class wxHashTable
wxHashTable * mywxHashTable;
// Looking at method wxHashTable::wxHashTable
unsigned int  * wxHashTablewxHashTablekey_type0;
int  * wxHashTablewxHashTablesize1;
wxHashTable * newwxHashTable0 = new wxHashTable( * wxHashTablewxHashTablekey_type0,  * wxHashTablewxHashTablesize1);
// Looking at method wxHashTable::BeginFind
mywxHashTable->BeginFind();
// Looking at method wxHashTable::Clear
mywxHashTable->Clear();
// Looking at method wxHashTable::Delete
long  * wxHashTableDeletekey0;
wxObject * retwxHashTableDelete0 = mywxHashTable->Delete( * wxHashTableDeletekey0);
wxString   * wxHashTableDeletekey1;
wxObject * retwxHashTableDelete1 = mywxHashTable->Delete( * wxHashTableDeletekey1);
// Looking at method wxHashTable::DeleteContents
bool  * wxHashTableDeleteContentsflag0;
mywxHashTable->DeleteContents( * wxHashTableDeleteContentsflag0);
// Looking at method wxHashTable::Get
long  * wxHashTableGetkey0;
wxObject * retwxHashTableGet0 = mywxHashTable->Get( * wxHashTableGetkey0);
char*  * wxHashTableGetkey1;
wxObject * retwxHashTableGet1 = mywxHashTable->Get( * wxHashTableGetkey1);
// Looking at method wxHashTable::MakeKey
wxString  * wxHashTableMakeKeystring0;
long retwxHashTableMakeKey0 = mywxHashTable->MakeKey( * wxHashTableMakeKeystring0);
// Looking at method wxHashTable::Next
wxHashTable::Node * retwxHashTableNext0 = mywxHashTable->Next();
// Looking at method wxHashTable::Put
long  * wxHashTablePutkey0;
wxObject * * wxHashTablePutobject1;
mywxHashTable->Put( * wxHashTablePutkey0,  * wxHashTablePutobject1);
char*  * wxHashTablePutkey2;
wxObject * * wxHashTablePutobject3;
mywxHashTable->Put( * wxHashTablePutkey2,  * wxHashTablePutobject3);
// Looking at method wxHashTable::GetCount
size_t retwxHashTableGetCount0 = mywxHashTable->GetCount();

// Looking at class wxHelpController
wxHelpController * mywxHelpController;
// Looking at method wxHelpController::wxHelpController
wxHelpController * newwxHelpController0 = new wxHelpController();
// Looking at method wxHelpController::Initialize
// Looking at method wxHelpController::DisplayBlock
// Looking at method wxHelpController::DisplayContents
// Looking at method wxHelpController::DisplayContextPopup
// Looking at method wxHelpController::DisplaySection
// Looking at method wxHelpController::DisplayTextPopup
// Looking at method wxHelpController::GetFrameParameters
// Looking at method wxHelpController::KeywordSearch
// Looking at method wxHelpController::LoadFile
// Looking at method wxHelpController::OnQuit
// Looking at method wxHelpController::SetFrameParameters
// Looking at method wxHelpController::SetViewer
// Looking at method wxHelpController::Quit

// Looking at class wxHelpControllerHelpProvider
wxHelpControllerHelpProvider * mywxHelpControllerHelpProvider;
// Looking at method wxHelpControllerHelpProvider::wxHelpControllerHelpProvider
wxHelpControllerBase*  * wxHelpControllerHelpProviderwxHelpControllerHelpProviderhc0;
wxHelpControllerHelpProvider * newwxHelpControllerHelpProvider0 = new wxHelpControllerHelpProvider( * wxHelpControllerHelpProviderwxHelpControllerHelpProviderhc0);
// Looking at method wxHelpControllerHelpProvider::SetHelpController
wxHelpControllerBase*  * wxHelpControllerHelpProviderSetHelpControllerhc0;
mywxHelpControllerHelpProvider->SetHelpController( * wxHelpControllerHelpProviderSetHelpControllerhc0);
// Looking at method wxHelpControllerHelpProvider::GetHelpController
wxHelpControllerBase* retwxHelpControllerHelpProviderGetHelpController0 = mywxHelpControllerHelpProvider->GetHelpController();

// Looking at class wxHelpEvent
wxHelpEvent * mywxHelpEvent;
// Looking at method wxHelpEvent::wxHelpEvent
WXTYPE  * wxHelpEventwxHelpEventeventType0;
wxWindowID  * wxHelpEventwxHelpEventid1;
wxPoint  * wxHelpEventwxHelpEventpoint2;
wxHelpEvent * newwxHelpEvent0 = new wxHelpEvent( * wxHelpEventwxHelpEventeventType0,  * wxHelpEventwxHelpEventid1,  * wxHelpEventwxHelpEventpoint2);
// Looking at method wxHelpEvent::GetPosition
const wxPoint retwxHelpEventGetPosition0 = mywxHelpEvent->GetPosition();
// Looking at method wxHelpEvent::SetPosition
wxPoint  * wxHelpEventSetPositionpt0;
mywxHelpEvent->SetPosition( * wxHelpEventSetPositionpt0);

// Looking at class wxHtmlCell
wxHtmlCell * mywxHtmlCell;
// Looking at method wxHtmlCell::wxHtmlCell
wxHtmlCell * newwxHtmlCell0 = new wxHtmlCell();
// Looking at method wxHtmlCell::AdjustPagebreak
// Looking at method wxHtmlCell::Draw
// Looking at method wxHtmlCell::DrawInvisible
// Looking at method wxHtmlCell::Find
// Looking at method wxHtmlCell::GetDescent
int retwxHtmlCellGetDescent0 = mywxHtmlCell->GetDescent();
// Looking at method wxHtmlCell::GetHeight
int retwxHtmlCellGetHeight0 = mywxHtmlCell->GetHeight();
// Looking at method wxHtmlCell::GetId
// Looking at method wxHtmlCell::GetLink
// Looking at method wxHtmlCell::GetNext
wxHtmlCell* retwxHtmlCellGetNext0 = mywxHtmlCell->GetNext();
// Looking at method wxHtmlCell::GetParent
wxHtmlContainerCell* retwxHtmlCellGetParent0 = mywxHtmlCell->GetParent();
// Looking at method wxHtmlCell::GetPosX
int retwxHtmlCellGetPosX0 = mywxHtmlCell->GetPosX();
// Looking at method wxHtmlCell::GetPosY
int retwxHtmlCellGetPosY0 = mywxHtmlCell->GetPosY();
// Looking at method wxHtmlCell::GetWidth
int retwxHtmlCellGetWidth0 = mywxHtmlCell->GetWidth();
// Looking at method wxHtmlCell::Layout
// Looking at method wxHtmlCell::OnMouseClick
// Looking at method wxHtmlCell::SetId
wxString  * wxHtmlCellSetIdid0;
mywxHtmlCell->SetId( * wxHtmlCellSetIdid0);
// Looking at method wxHtmlCell::SetLink
wxHtmlLinkInfo  * wxHtmlCellSetLinklink0;
mywxHtmlCell->SetLink( * wxHtmlCellSetLinklink0);
// Looking at method wxHtmlCell::SetNext
wxHtmlCell * * wxHtmlCellSetNextcell0;
mywxHtmlCell->SetNext( * wxHtmlCellSetNextcell0);
// Looking at method wxHtmlCell::SetParent
wxHtmlContainerCell * * wxHtmlCellSetParentp0;
mywxHtmlCell->SetParent( * wxHtmlCellSetParentp0);
// Looking at method wxHtmlCell::SetPos
int  * wxHtmlCellSetPosx0;
int  * wxHtmlCellSetPosy1;
mywxHtmlCell->SetPos( * wxHtmlCellSetPosx0,  * wxHtmlCellSetPosy1);

// Looking at class wxHtmlColourCell
wxHtmlColourCell * mywxHtmlColourCell;
// Looking at method wxHtmlColourCell::wxHtmlColourCell
wxColour  * wxHtmlColourCellwxHtmlColourCellclr0;
int  * wxHtmlColourCellwxHtmlColourCellflags1;
wxHtmlColourCell * newwxHtmlColourCell0 = new wxHtmlColourCell( * wxHtmlColourCellwxHtmlColourCellclr0,  * wxHtmlColourCellwxHtmlColourCellflags1);

// Looking at class wxHtmlContainerCell
wxHtmlContainerCell * mywxHtmlContainerCell;
// Looking at method wxHtmlContainerCell::wxHtmlContainerCell
wxHtmlContainerCell * * wxHtmlContainerCellwxHtmlContainerCellparent0;
wxHtmlContainerCell * newwxHtmlContainerCell0 = new wxHtmlContainerCell( * wxHtmlContainerCellwxHtmlContainerCellparent0);
// Looking at method wxHtmlContainerCell::GetAlignHor
int retwxHtmlContainerCellGetAlignHor0 = mywxHtmlContainerCell->GetAlignHor();
// Looking at method wxHtmlContainerCell::GetAlignVer
int retwxHtmlContainerCellGetAlignVer0 = mywxHtmlContainerCell->GetAlignVer();
// Looking at method wxHtmlContainerCell::GetBackgroundColour
wxColour retwxHtmlContainerCellGetBackgroundColour0 = mywxHtmlContainerCell->GetBackgroundColour();
// Looking at method wxHtmlContainerCell::GetFirstCell
wxHtmlCell* retwxHtmlContainerCellGetFirstCell0 = mywxHtmlContainerCell->GetFirstCell();
// Looking at method wxHtmlContainerCell::GetIndent
int  * wxHtmlContainerCellGetIndentind0;
int retwxHtmlContainerCellGetIndent0 = mywxHtmlContainerCell->GetIndent( * wxHtmlContainerCellGetIndentind0);
// Looking at method wxHtmlContainerCell::GetIndentUnits
int  * wxHtmlContainerCellGetIndentUnitsind0;
int retwxHtmlContainerCellGetIndentUnits0 = mywxHtmlContainerCell->GetIndentUnits( * wxHtmlContainerCellGetIndentUnitsind0);
// Looking at method wxHtmlContainerCell::InsertCell
wxHtmlCell * * wxHtmlContainerCellInsertCellcell0;
mywxHtmlContainerCell->InsertCell( * wxHtmlContainerCellInsertCellcell0);
// Looking at method wxHtmlContainerCell::SetAlign
wxHtmlTag  * wxHtmlContainerCellSetAligntag0;
mywxHtmlContainerCell->SetAlign( * wxHtmlContainerCellSetAligntag0);
// Looking at method wxHtmlContainerCell::SetAlignHor
int  * wxHtmlContainerCellSetAlignHoral0;
mywxHtmlContainerCell->SetAlignHor( * wxHtmlContainerCellSetAlignHoral0);
// Looking at method wxHtmlContainerCell::SetAlignVer
int  * wxHtmlContainerCellSetAlignVeral0;
mywxHtmlContainerCell->SetAlignVer( * wxHtmlContainerCellSetAlignVeral0);
// Looking at method wxHtmlContainerCell::SetBackgroundColour
wxColour  * wxHtmlContainerCellSetBackgroundColourclr0;
mywxHtmlContainerCell->SetBackgroundColour( * wxHtmlContainerCellSetBackgroundColourclr0);
// Looking at method wxHtmlContainerCell::SetBorder
wxColour  * wxHtmlContainerCellSetBorderclr10;
wxColour  * wxHtmlContainerCellSetBorderclr21;
mywxHtmlContainerCell->SetBorder( * wxHtmlContainerCellSetBorderclr10,  * wxHtmlContainerCellSetBorderclr21);
// Looking at method wxHtmlContainerCell::SetIndent
int  * wxHtmlContainerCellSetIndenti0;
int  * wxHtmlContainerCellSetIndentwhat1;
int  * wxHtmlContainerCellSetIndentunits2;
mywxHtmlContainerCell->SetIndent( * wxHtmlContainerCellSetIndenti0,  * wxHtmlContainerCellSetIndentwhat1,  * wxHtmlContainerCellSetIndentunits2);
// Looking at method wxHtmlContainerCell::SetMinHeight
int  * wxHtmlContainerCellSetMinHeighth0;
int  * wxHtmlContainerCellSetMinHeightalign1;
mywxHtmlContainerCell->SetMinHeight( * wxHtmlContainerCellSetMinHeighth0,  * wxHtmlContainerCellSetMinHeightalign1);
// Looking at method wxHtmlContainerCell::SetWidthFloat
int  * wxHtmlContainerCellSetWidthFloatw0;
int  * wxHtmlContainerCellSetWidthFloatunits1;
mywxHtmlContainerCell->SetWidthFloat( * wxHtmlContainerCellSetWidthFloatw0,  * wxHtmlContainerCellSetWidthFloatunits1);
wxHtmlTag  * wxHtmlContainerCellSetWidthFloattag2;
double  * wxHtmlContainerCellSetWidthFloatpixel_scale3;
mywxHtmlContainerCell->SetWidthFloat( * wxHtmlContainerCellSetWidthFloattag2,  * wxHtmlContainerCellSetWidthFloatpixel_scale3);

// Looking at class wxHtmlDCRenderer
wxHtmlDCRenderer * mywxHtmlDCRenderer;
// Looking at method wxHtmlDCRenderer::wxHtmlDCRenderer
wxHtmlDCRenderer * newwxHtmlDCRenderer0 = new wxHtmlDCRenderer();
// Looking at method wxHtmlDCRenderer::SetDC
wxDC*  * wxHtmlDCRendererSetDCdc0;
double  * wxHtmlDCRendererSetDCpixel_scale1;
mywxHtmlDCRenderer->SetDC( * wxHtmlDCRendererSetDCdc0,  * wxHtmlDCRendererSetDCpixel_scale1);
// Looking at method wxHtmlDCRenderer::SetFonts
wxString  * wxHtmlDCRendererSetFontsnormal_face0;
wxString  * wxHtmlDCRendererSetFontsfixed_face1;
int * * wxHtmlDCRendererSetFontssizes2;
mywxHtmlDCRenderer->SetFonts( * wxHtmlDCRendererSetFontsnormal_face0,  * wxHtmlDCRendererSetFontsfixed_face1,  * wxHtmlDCRendererSetFontssizes2);
// Looking at method wxHtmlDCRenderer::SetSize
int  * wxHtmlDCRendererSetSizewidth0;
int  * wxHtmlDCRendererSetSizeheight1;
mywxHtmlDCRenderer->SetSize( * wxHtmlDCRendererSetSizewidth0,  * wxHtmlDCRendererSetSizeheight1);
// Looking at method wxHtmlDCRenderer::SetHtmlText
wxString  * wxHtmlDCRendererSetHtmlTexthtml0;
wxString  * wxHtmlDCRendererSetHtmlTextbasepath1;
bool  * wxHtmlDCRendererSetHtmlTextisdir2;
mywxHtmlDCRenderer->SetHtmlText( * wxHtmlDCRendererSetHtmlTexthtml0,  * wxHtmlDCRendererSetHtmlTextbasepath1,  * wxHtmlDCRendererSetHtmlTextisdir2);
// Looking at method wxHtmlDCRenderer::Render
int  * wxHtmlDCRendererRenderx0;
int  * wxHtmlDCRendererRendery1;
int  * wxHtmlDCRendererRenderfrom2;
int  * wxHtmlDCRendererRenderdont_render3;
int retwxHtmlDCRendererRender0 = mywxHtmlDCRenderer->Render( * wxHtmlDCRendererRenderx0,  * wxHtmlDCRendererRendery1,  * wxHtmlDCRendererRenderfrom2,  * wxHtmlDCRendererRenderdont_render3);
// Looking at method wxHtmlDCRenderer::GetTotalHeight
int retwxHtmlDCRendererGetTotalHeight0 = mywxHtmlDCRenderer->GetTotalHeight();

// Looking at class wxHtmlEasyPrinting
wxHtmlEasyPrinting * mywxHtmlEasyPrinting;
// Looking at method wxHtmlEasyPrinting::wxHtmlEasyPrinting
wxString  * wxHtmlEasyPrintingwxHtmlEasyPrintingname0;
wxWindow*  * wxHtmlEasyPrintingwxHtmlEasyPrintingparentWindow1;
wxHtmlEasyPrinting * newwxHtmlEasyPrinting0 = new wxHtmlEasyPrinting( * wxHtmlEasyPrintingwxHtmlEasyPrintingname0,  * wxHtmlEasyPrintingwxHtmlEasyPrintingparentWindow1);
// Looking at method wxHtmlEasyPrinting::PreviewFile
wxString  * wxHtmlEasyPrintingPreviewFilehtmlfile0;
bool retwxHtmlEasyPrintingPreviewFile0 = mywxHtmlEasyPrinting->PreviewFile( * wxHtmlEasyPrintingPreviewFilehtmlfile0);
// Looking at method wxHtmlEasyPrinting::PreviewText
wxString  * wxHtmlEasyPrintingPreviewTexthtmltext0;
wxString  * wxHtmlEasyPrintingPreviewTextbasepath1;
bool retwxHtmlEasyPrintingPreviewText0 = mywxHtmlEasyPrinting->PreviewText( * wxHtmlEasyPrintingPreviewTexthtmltext0,  * wxHtmlEasyPrintingPreviewTextbasepath1);
// Looking at method wxHtmlEasyPrinting::PrintFile
wxString  * wxHtmlEasyPrintingPrintFilehtmlfile0;
bool retwxHtmlEasyPrintingPrintFile0 = mywxHtmlEasyPrinting->PrintFile( * wxHtmlEasyPrintingPrintFilehtmlfile0);
// Looking at method wxHtmlEasyPrinting::PrintText
wxString  * wxHtmlEasyPrintingPrintTexthtmltext0;
wxString  * wxHtmlEasyPrintingPrintTextbasepath1;
bool retwxHtmlEasyPrintingPrintText0 = mywxHtmlEasyPrinting->PrintText( * wxHtmlEasyPrintingPrintTexthtmltext0,  * wxHtmlEasyPrintingPrintTextbasepath1);
// Looking at method wxHtmlEasyPrinting::PageSetup
mywxHtmlEasyPrinting->PageSetup();
// Looking at method wxHtmlEasyPrinting::SetFonts
wxString  * wxHtmlEasyPrintingSetFontsnormal_face0;
wxString  * wxHtmlEasyPrintingSetFontsfixed_face1;
int * * wxHtmlEasyPrintingSetFontssizes2;
mywxHtmlEasyPrinting->SetFonts( * wxHtmlEasyPrintingSetFontsnormal_face0,  * wxHtmlEasyPrintingSetFontsfixed_face1,  * wxHtmlEasyPrintingSetFontssizes2);
// Looking at method wxHtmlEasyPrinting::SetHeader
wxString  * wxHtmlEasyPrintingSetHeaderheader0;
int  * wxHtmlEasyPrintingSetHeaderpg1;
mywxHtmlEasyPrinting->SetHeader( * wxHtmlEasyPrintingSetHeaderheader0,  * wxHtmlEasyPrintingSetHeaderpg1);
// Looking at method wxHtmlEasyPrinting::SetFooter
wxString  * wxHtmlEasyPrintingSetFooterfooter0;
int  * wxHtmlEasyPrintingSetFooterpg1;
mywxHtmlEasyPrinting->SetFooter( * wxHtmlEasyPrintingSetFooterfooter0,  * wxHtmlEasyPrintingSetFooterpg1);
// Looking at method wxHtmlEasyPrinting::GetPrintData
wxPrintData* retwxHtmlEasyPrintingGetPrintData0 = mywxHtmlEasyPrinting->GetPrintData();
// Looking at method wxHtmlEasyPrinting::GetPageSetupData
wxPageSetupDialogData* retwxHtmlEasyPrintingGetPageSetupData0 = mywxHtmlEasyPrinting->GetPageSetupData();

// Looking at class wxHtmlHelpController
wxHtmlHelpController * mywxHtmlHelpController;
// Looking at method wxHtmlHelpController::wxHtmlHelpController
int  * wxHtmlHelpControllerwxHtmlHelpControllerstyle0;
wxHtmlHelpController * newwxHtmlHelpController0 = new wxHtmlHelpController( * wxHtmlHelpControllerwxHtmlHelpControllerstyle0);
// Looking at method wxHtmlHelpController::AddBook
wxFileName  * wxHtmlHelpControllerAddBookbook_file0;
bool  * wxHtmlHelpControllerAddBookshow_wait_msg1;
bool retwxHtmlHelpControllerAddBook0 = mywxHtmlHelpController->AddBook( * wxHtmlHelpControllerAddBookbook_file0,  * wxHtmlHelpControllerAddBookshow_wait_msg1);
wxString  * wxHtmlHelpControllerAddBookbook_url2;
bool  * wxHtmlHelpControllerAddBookshow_wait_msg3;
bool retwxHtmlHelpControllerAddBook1 = mywxHtmlHelpController->AddBook( * wxHtmlHelpControllerAddBookbook_url2,  * wxHtmlHelpControllerAddBookshow_wait_msg3);
// Looking at method wxHtmlHelpController::CreateHelpFrame
// Looking at method wxHtmlHelpController::Display
wxString  * wxHtmlHelpControllerDisplayx0;
mywxHtmlHelpController->Display( * wxHtmlHelpControllerDisplayx0);
int  * wxHtmlHelpControllerDisplayid1;
mywxHtmlHelpController->Display( * wxHtmlHelpControllerDisplayid1);
// Looking at method wxHtmlHelpController::DisplayContents
mywxHtmlHelpController->DisplayContents();
// Looking at method wxHtmlHelpController::DisplayIndex
mywxHtmlHelpController->DisplayIndex();
// Looking at method wxHtmlHelpController::KeywordSearch
wxString  * wxHtmlHelpControllerKeywordSearchkeyword0;
wxHelpSearchMode  * wxHtmlHelpControllerKeywordSearchmode1;
bool retwxHtmlHelpControllerKeywordSearch0 = mywxHtmlHelpController->KeywordSearch( * wxHtmlHelpControllerKeywordSearchkeyword0,  * wxHtmlHelpControllerKeywordSearchmode1);
// Looking at method wxHtmlHelpController::ReadCustomization
wxConfigBase*  * wxHtmlHelpControllerReadCustomizationcfg0;
wxString  * wxHtmlHelpControllerReadCustomizationpath1;
mywxHtmlHelpController->ReadCustomization( * wxHtmlHelpControllerReadCustomizationcfg0,  * wxHtmlHelpControllerReadCustomizationpath1);
// Looking at method wxHtmlHelpController::SetTempDir
wxString  * wxHtmlHelpControllerSetTempDirpath0;
mywxHtmlHelpController->SetTempDir( * wxHtmlHelpControllerSetTempDirpath0);
// Looking at method wxHtmlHelpController::SetTitleFormat
wxString  * wxHtmlHelpControllerSetTitleFormatformat0;
mywxHtmlHelpController->SetTitleFormat( * wxHtmlHelpControllerSetTitleFormatformat0);
// Looking at method wxHtmlHelpController::UseConfig
wxConfigBase*  * wxHtmlHelpControllerUseConfigconfig0;
wxString  * wxHtmlHelpControllerUseConfigrootpath1;
mywxHtmlHelpController->UseConfig( * wxHtmlHelpControllerUseConfigconfig0,  * wxHtmlHelpControllerUseConfigrootpath1);
// Looking at method wxHtmlHelpController::WriteCustomization
wxConfigBase*  * wxHtmlHelpControllerWriteCustomizationcfg0;
wxString  * wxHtmlHelpControllerWriteCustomizationpath1;
mywxHtmlHelpController->WriteCustomization( * wxHtmlHelpControllerWriteCustomizationcfg0,  * wxHtmlHelpControllerWriteCustomizationpath1);

// Looking at class wxHtmlHelpData
wxHtmlHelpData * mywxHtmlHelpData;
// Looking at method wxHtmlHelpData::wxHtmlHelpData
wxHtmlHelpData * newwxHtmlHelpData0 = new wxHtmlHelpData();
// Looking at method wxHtmlHelpData::AddBook
wxString  * wxHtmlHelpDataAddBookbook_url0;
bool retwxHtmlHelpDataAddBook0 = mywxHtmlHelpData->AddBook( * wxHtmlHelpDataAddBookbook_url0);
// Looking at method wxHtmlHelpData::FindPageById
int  * wxHtmlHelpDataFindPageByIdid0;
wxString retwxHtmlHelpDataFindPageById0 = mywxHtmlHelpData->FindPageById( * wxHtmlHelpDataFindPageByIdid0);
// Looking at method wxHtmlHelpData::FindPageByName
wxString  * wxHtmlHelpDataFindPageByNamepage0;
wxString retwxHtmlHelpDataFindPageByName0 = mywxHtmlHelpData->FindPageByName( * wxHtmlHelpDataFindPageByNamepage0);
// Looking at method wxHtmlHelpData::GetBookRecArray
const wxHtmlBookRecArray retwxHtmlHelpDataGetBookRecArray0 = mywxHtmlHelpData->GetBookRecArray();
// Looking at method wxHtmlHelpData::GetContentsArray
const wxHtmlHelpDataItems retwxHtmlHelpDataGetContentsArray0 = mywxHtmlHelpData->GetContentsArray();
// Looking at method wxHtmlHelpData::GetIndexArray
const wxHtmlHelpDataItems retwxHtmlHelpDataGetIndexArray0 = mywxHtmlHelpData->GetIndexArray();
// Looking at method wxHtmlHelpData::SetTempDir
wxString  * wxHtmlHelpDataSetTempDirpath0;
mywxHtmlHelpData->SetTempDir( * wxHtmlHelpDataSetTempDirpath0);

// Looking at class wxHtmlHelpFrame
wxHtmlHelpFrame * mywxHtmlHelpFrame;
// Looking at method wxHtmlHelpFrame::wxHtmlHelpFrame
wxHtmlHelpData*  * wxHtmlHelpFramewxHtmlHelpFramedata0;
wxHtmlHelpFrame * newwxHtmlHelpFrame0 = new wxHtmlHelpFrame( * wxHtmlHelpFramewxHtmlHelpFramedata0);
wxWindow*  * wxHtmlHelpFramewxHtmlHelpFrameparent1;
int  * wxHtmlHelpFramewxHtmlHelpFramewxWindowID2;
wxString  * wxHtmlHelpFramewxHtmlHelpFrametitle3;
int  * wxHtmlHelpFramewxHtmlHelpFramestyle4;
wxHtmlHelpData*  * wxHtmlHelpFramewxHtmlHelpFramedata5;
wxHtmlHelpFrame * newwxHtmlHelpFrame1 = new wxHtmlHelpFrame( * wxHtmlHelpFramewxHtmlHelpFrameparent1,  * wxHtmlHelpFramewxHtmlHelpFramewxWindowID2,  * wxHtmlHelpFramewxHtmlHelpFrametitle3,  * wxHtmlHelpFramewxHtmlHelpFramestyle4,  * wxHtmlHelpFramewxHtmlHelpFramedata5);
// Looking at method wxHtmlHelpFrame::Create
wxWindow*  * wxHtmlHelpFrameCreateparent0;
wxWindowID  * wxHtmlHelpFrameCreateid1;
wxString  * wxHtmlHelpFrameCreatetitle2;
int  * wxHtmlHelpFrameCreatestyle3;
bool retwxHtmlHelpFrameCreate0 = mywxHtmlHelpFrame->Create( * wxHtmlHelpFrameCreateparent0,  * wxHtmlHelpFrameCreateid1,  * wxHtmlHelpFrameCreatetitle2,  * wxHtmlHelpFrameCreatestyle3);
// Looking at method wxHtmlHelpFrame::CreateContents
mywxHtmlHelpFrame->CreateContents();
// Looking at method wxHtmlHelpFrame::CreateIndex
mywxHtmlHelpFrame->CreateIndex();
// Looking at method wxHtmlHelpFrame::CreateSearch
mywxHtmlHelpFrame->CreateSearch();
// Looking at method wxHtmlHelpFrame::Display
wxString  * wxHtmlHelpFrameDisplayx0;
bool retwxHtmlHelpFrameDisplay0 = mywxHtmlHelpFrame->Display( * wxHtmlHelpFrameDisplayx0);
int  * wxHtmlHelpFrameDisplayid1;
bool retwxHtmlHelpFrameDisplay1 = mywxHtmlHelpFrame->Display( * wxHtmlHelpFrameDisplayid1);
// Looking at method wxHtmlHelpFrame::DisplayContents
bool retwxHtmlHelpFrameDisplayContents0 = mywxHtmlHelpFrame->DisplayContents();
// Looking at method wxHtmlHelpFrame::DisplayIndex
bool retwxHtmlHelpFrameDisplayIndex0 = mywxHtmlHelpFrame->DisplayIndex();
// Looking at method wxHtmlHelpFrame::GetData
wxHtmlHelpData* retwxHtmlHelpFrameGetData0 = mywxHtmlHelpFrame->GetData();
// Looking at method wxHtmlHelpFrame::KeywordSearch
wxString  * wxHtmlHelpFrameKeywordSearchkeyword0;
wxHelpSearchMode  * wxHtmlHelpFrameKeywordSearchmode1;
bool retwxHtmlHelpFrameKeywordSearch0 = mywxHtmlHelpFrame->KeywordSearch( * wxHtmlHelpFrameKeywordSearchkeyword0,  * wxHtmlHelpFrameKeywordSearchmode1);
// Looking at method wxHtmlHelpFrame::ReadCustomization
wxConfigBase*  * wxHtmlHelpFrameReadCustomizationcfg0;
wxString  * wxHtmlHelpFrameReadCustomizationpath1;
mywxHtmlHelpFrame->ReadCustomization( * wxHtmlHelpFrameReadCustomizationcfg0,  * wxHtmlHelpFrameReadCustomizationpath1);
// Looking at method wxHtmlHelpFrame::RefreshLists
mywxHtmlHelpFrame->RefreshLists();
// Looking at method wxHtmlHelpFrame::SetTitleFormat
wxString  * wxHtmlHelpFrameSetTitleFormatformat0;
mywxHtmlHelpFrame->SetTitleFormat( * wxHtmlHelpFrameSetTitleFormatformat0);
// Looking at method wxHtmlHelpFrame::UseConfig
wxConfigBase*  * wxHtmlHelpFrameUseConfigconfig0;
wxString  * wxHtmlHelpFrameUseConfigrootpath1;
mywxHtmlHelpFrame->UseConfig( * wxHtmlHelpFrameUseConfigconfig0,  * wxHtmlHelpFrameUseConfigrootpath1);
// Looking at method wxHtmlHelpFrame::WriteCustomization
wxConfigBase*  * wxHtmlHelpFrameWriteCustomizationcfg0;
wxString  * wxHtmlHelpFrameWriteCustomizationpath1;
mywxHtmlHelpFrame->WriteCustomization( * wxHtmlHelpFrameWriteCustomizationcfg0,  * wxHtmlHelpFrameWriteCustomizationpath1);
// Looking at method wxHtmlHelpFrame::AddToolbarButtons

// Looking at class wxHtmlLinkInfo
wxHtmlLinkInfo * mywxHtmlLinkInfo;
// Looking at method wxHtmlLinkInfo::wxHtmlLinkInfo
wxHtmlLinkInfo * newwxHtmlLinkInfo0 = new wxHtmlLinkInfo();
wxString  * wxHtmlLinkInfowxHtmlLinkInfohref0;
wxString  * wxHtmlLinkInfowxHtmlLinkInfotarget1;
wxHtmlLinkInfo * newwxHtmlLinkInfo1 = new wxHtmlLinkInfo( * wxHtmlLinkInfowxHtmlLinkInfohref0,  * wxHtmlLinkInfowxHtmlLinkInfotarget1);
// Looking at method wxHtmlLinkInfo::GetEvent
const wxMouseEvent * retwxHtmlLinkInfoGetEvent0 = mywxHtmlLinkInfo->GetEvent();
// Looking at method wxHtmlLinkInfo::GetHtmlCell
const wxHtmlCell * retwxHtmlLinkInfoGetHtmlCell0 = mywxHtmlLinkInfo->GetHtmlCell();
// Looking at method wxHtmlLinkInfo::GetHref
wxString retwxHtmlLinkInfoGetHref0 = mywxHtmlLinkInfo->GetHref();
// Looking at method wxHtmlLinkInfo::GetTarget
wxString retwxHtmlLinkInfoGetTarget0 = mywxHtmlLinkInfo->GetTarget();

// Looking at class wxHtmlParser
wxHtmlParser * mywxHtmlParser;
// Looking at method wxHtmlParser::wxHtmlParser
wxHtmlParser * newwxHtmlParser0 = new wxHtmlParser();
// Looking at method wxHtmlParser::AddTag
wxHtmlTag  * wxHtmlParserAddTagtag0;
mywxHtmlParser->AddTag( * wxHtmlParserAddTagtag0);
// Looking at method wxHtmlParser::AddTagHandler
// Looking at method wxHtmlParser::AddText
// Looking at method wxHtmlParser::DoParsing
int  * wxHtmlParserDoParsingbegin_pos0;
int  * wxHtmlParserDoParsingend_pos1;
mywxHtmlParser->DoParsing( * wxHtmlParserDoParsingbegin_pos0,  * wxHtmlParserDoParsingend_pos1);
mywxHtmlParser->DoParsing();
// Looking at method wxHtmlParser::DoneParser
// Looking at method wxHtmlParser::GetFS
wxFileSystem* retwxHtmlParserGetFS0 = mywxHtmlParser->GetFS();
// Looking at method wxHtmlParser::GetProduct
// Looking at method wxHtmlParser::GetSource
wxString* retwxHtmlParserGetSource0 = mywxHtmlParser->GetSource();
// Looking at method wxHtmlParser::InitParser
// Looking at method wxHtmlParser::OpenURL
// Looking at method wxHtmlParser::Parse
wxString  * wxHtmlParserParsesource0;
wxObject* retwxHtmlParserParse0 = mywxHtmlParser->Parse( * wxHtmlParserParsesource0);
// Looking at method wxHtmlParser::PushTagHandler
wxHtmlTagHandler*  * wxHtmlParserPushTagHandlerhandler0;
wxString  * wxHtmlParserPushTagHandlertags1;
mywxHtmlParser->PushTagHandler( * wxHtmlParserPushTagHandlerhandler0,  * wxHtmlParserPushTagHandlertags1);
// Looking at method wxHtmlParser::PopTagHandler
mywxHtmlParser->PopTagHandler();
// Looking at method wxHtmlParser::SetFS
wxFileSystem * * wxHtmlParserSetFSfs0;
mywxHtmlParser->SetFS( * wxHtmlParserSetFSfs0);
// Looking at method wxHtmlParser::StopParsing
mywxHtmlParser->StopParsing();

// Looking at class wxHtmlPrintout
wxHtmlPrintout * mywxHtmlPrintout;
// Looking at method wxHtmlPrintout::wxHtmlPrintout
wxString  * wxHtmlPrintoutwxHtmlPrintouttitle0;
wxHtmlPrintout * newwxHtmlPrintout0 = new wxHtmlPrintout( * wxHtmlPrintoutwxHtmlPrintouttitle0);
// Looking at method wxHtmlPrintout::AddFilter
wxHtmlFilter*  * wxHtmlPrintoutAddFilterfilter0;
mywxHtmlPrintout->AddFilter( * wxHtmlPrintoutAddFilterfilter0);
// Looking at method wxHtmlPrintout::SetFonts
wxString  * wxHtmlPrintoutSetFontsnormal_face0;
wxString  * wxHtmlPrintoutSetFontsfixed_face1;
int * * wxHtmlPrintoutSetFontssizes2;
mywxHtmlPrintout->SetFonts( * wxHtmlPrintoutSetFontsnormal_face0,  * wxHtmlPrintoutSetFontsfixed_face1,  * wxHtmlPrintoutSetFontssizes2);
// Looking at method wxHtmlPrintout::SetFooter
wxString  * wxHtmlPrintoutSetFooterfooter0;
int  * wxHtmlPrintoutSetFooterpg1;
mywxHtmlPrintout->SetFooter( * wxHtmlPrintoutSetFooterfooter0,  * wxHtmlPrintoutSetFooterpg1);
// Looking at method wxHtmlPrintout::SetHeader
wxString  * wxHtmlPrintoutSetHeaderheader0;
int  * wxHtmlPrintoutSetHeaderpg1;
mywxHtmlPrintout->SetHeader( * wxHtmlPrintoutSetHeaderheader0,  * wxHtmlPrintoutSetHeaderpg1);
// Looking at method wxHtmlPrintout::SetHtmlFile
wxString  * wxHtmlPrintoutSetHtmlFilehtmlfile0;
mywxHtmlPrintout->SetHtmlFile( * wxHtmlPrintoutSetHtmlFilehtmlfile0);
// Looking at method wxHtmlPrintout::SetHtmlText
wxString  * wxHtmlPrintoutSetHtmlTexthtml0;
wxString  * wxHtmlPrintoutSetHtmlTextbasepath1;
bool  * wxHtmlPrintoutSetHtmlTextisdir2;
mywxHtmlPrintout->SetHtmlText( * wxHtmlPrintoutSetHtmlTexthtml0,  * wxHtmlPrintoutSetHtmlTextbasepath1,  * wxHtmlPrintoutSetHtmlTextisdir2);
// Looking at method wxHtmlPrintout::SetMargins
float  * wxHtmlPrintoutSetMarginstop0;
float  * wxHtmlPrintoutSetMarginsbottom1;
float  * wxHtmlPrintoutSetMarginsleft2;
float  * wxHtmlPrintoutSetMarginsright3;
float  * wxHtmlPrintoutSetMarginsspaces4;
mywxHtmlPrintout->SetMargins( * wxHtmlPrintoutSetMarginstop0,  * wxHtmlPrintoutSetMarginsbottom1,  * wxHtmlPrintoutSetMarginsleft2,  * wxHtmlPrintoutSetMarginsright3,  * wxHtmlPrintoutSetMarginsspaces4);

// Looking at class wxHtmlTag
wxHtmlTag * mywxHtmlTag;
// Looking at method wxHtmlTag::wxHtmlTag
wxHtmlTag * * wxHtmlTagwxHtmlTagparent0;
wxString  * wxHtmlTagwxHtmlTagsource1;
int  * wxHtmlTagwxHtmlTagpos2;
int  * wxHtmlTagwxHtmlTagend_pos3;
wxHtmlTagsCache*  * wxHtmlTagwxHtmlTagcache4;
wxHtmlEntitiesParser * * wxHtmlTagwxHtmlTagentParser5;
wxHtmlTag * newwxHtmlTag0 = new wxHtmlTag( * wxHtmlTagwxHtmlTagparent0,  * wxHtmlTagwxHtmlTagsource1,  * wxHtmlTagwxHtmlTagpos2,  * wxHtmlTagwxHtmlTagend_pos3,  * wxHtmlTagwxHtmlTagcache4,  * wxHtmlTagwxHtmlTagentParser5);
// Looking at method wxHtmlTag::GetAllParams
const wxString retwxHtmlTagGetAllParams0 = mywxHtmlTag->GetAllParams();
// Looking at method wxHtmlTag::GetBeginPos
int retwxHtmlTagGetBeginPos0 = mywxHtmlTag->GetBeginPos();
// Looking at method wxHtmlTag::GetEndPos1
int retwxHtmlTagGetEndPos10 = mywxHtmlTag->GetEndPos1();
// Looking at method wxHtmlTag::GetEndPos2
int retwxHtmlTagGetEndPos20 = mywxHtmlTag->GetEndPos2();
// Looking at method wxHtmlTag::GetName
wxString retwxHtmlTagGetName0 = mywxHtmlTag->GetName();
// Looking at method wxHtmlTag::GetParam
wxString  * wxHtmlTagGetParampar0;
bool  * wxHtmlTagGetParamwith_commas1;
wxString retwxHtmlTagGetParam0 = mywxHtmlTag->GetParam( * wxHtmlTagGetParampar0,  * wxHtmlTagGetParamwith_commas1);
// Looking at method wxHtmlTag::GetParamAsColour
wxString  * wxHtmlTagGetParamAsColourpar0;
wxColour * * wxHtmlTagGetParamAsColourclr1;
bool retwxHtmlTagGetParamAsColour0 = mywxHtmlTag->GetParamAsColour( * wxHtmlTagGetParamAsColourpar0,  * wxHtmlTagGetParamAsColourclr1);
// Looking at method wxHtmlTag::GetParamAsInt
wxString  * wxHtmlTagGetParamAsIntpar0;
int * * wxHtmlTagGetParamAsIntvalue1;
bool retwxHtmlTagGetParamAsInt0 = mywxHtmlTag->GetParamAsInt( * wxHtmlTagGetParamAsIntpar0,  * wxHtmlTagGetParamAsIntvalue1);
// Looking at method wxHtmlTag::HasEnding
bool retwxHtmlTagHasEnding0 = mywxHtmlTag->HasEnding();
// Looking at method wxHtmlTag::HasParam
wxString  * wxHtmlTagHasParampar0;
bool retwxHtmlTagHasParam0 = mywxHtmlTag->HasParam( * wxHtmlTagHasParampar0);
// Looking at method wxHtmlTag::ScanParam
wxString  * wxHtmlTagScanParampar0;
wxChar * * wxHtmlTagScanParamformat1;
void * * wxHtmlTagScanParamvalue2;
wxString retwxHtmlTagScanParam0 = mywxHtmlTag->ScanParam( * wxHtmlTagScanParampar0,  * wxHtmlTagScanParamformat1,  * wxHtmlTagScanParamvalue2);

// Looking at class wxHtmlTagsModule
wxHtmlTagsModule * mywxHtmlTagsModule;
// Looking at method wxHtmlTagsModule::FillHandlersTable

// Looking at class wxHtmlWidgetCell
wxHtmlWidgetCell * mywxHtmlWidgetCell;
// Looking at method wxHtmlWidgetCell::wxHtmlWidgetCell
wxWindow*  * wxHtmlWidgetCellwxHtmlWidgetCellwnd0;
int  * wxHtmlWidgetCellwxHtmlWidgetCellw1;
wxHtmlWidgetCell * newwxHtmlWidgetCell0 = new wxHtmlWidgetCell( * wxHtmlWidgetCellwxHtmlWidgetCellwnd0,  * wxHtmlWidgetCellwxHtmlWidgetCellw1);

// Looking at class wxHtmlWinParser
wxHtmlWinParser * mywxHtmlWinParser;
// Looking at method wxHtmlWinParser::wxHtmlWinParser
wxHtmlWinParser * newwxHtmlWinParser0 = new wxHtmlWinParser();
wxHtmlWindow * * wxHtmlWinParserwxHtmlWinParserwnd0;
wxHtmlWinParser * newwxHtmlWinParser1 = new wxHtmlWinParser( * wxHtmlWinParserwxHtmlWinParserwnd0);
// Looking at method wxHtmlWinParser::AddModule
wxHtmlTagsModule * * wxHtmlWinParserAddModulemodule0;
mywxHtmlWinParser->AddModule( * wxHtmlWinParserAddModulemodule0);
// Looking at method wxHtmlWinParser::CloseContainer
wxHtmlContainerCell* retwxHtmlWinParserCloseContainer0 = mywxHtmlWinParser->CloseContainer();
// Looking at method wxHtmlWinParser::CreateCurrentFont
// Looking at method wxHtmlWinParser::GetActualColor
const wxColour retwxHtmlWinParserGetActualColor0 = mywxHtmlWinParser->GetActualColor();
// Looking at method wxHtmlWinParser::GetAlign
int retwxHtmlWinParserGetAlign0 = mywxHtmlWinParser->GetAlign();
// Looking at method wxHtmlWinParser::GetCharHeight
int retwxHtmlWinParserGetCharHeight0 = mywxHtmlWinParser->GetCharHeight();
// Looking at method wxHtmlWinParser::GetCharWidth
int retwxHtmlWinParserGetCharWidth0 = mywxHtmlWinParser->GetCharWidth();
// Looking at method wxHtmlWinParser::GetContainer
wxHtmlContainerCell* retwxHtmlWinParserGetContainer0 = mywxHtmlWinParser->GetContainer();
// Looking at method wxHtmlWinParser::GetDC
wxDC* retwxHtmlWinParserGetDC0 = mywxHtmlWinParser->GetDC();
// Looking at method wxHtmlWinParser::GetEncodingConverter
wxEncodingConverter * retwxHtmlWinParserGetEncodingConverter0 = mywxHtmlWinParser->GetEncodingConverter();
// Looking at method wxHtmlWinParser::GetFontBold
int retwxHtmlWinParserGetFontBold0 = mywxHtmlWinParser->GetFontBold();
// Looking at method wxHtmlWinParser::GetFontFace
wxString retwxHtmlWinParserGetFontFace0 = mywxHtmlWinParser->GetFontFace();
// Looking at method wxHtmlWinParser::GetFontFixed
int retwxHtmlWinParserGetFontFixed0 = mywxHtmlWinParser->GetFontFixed();
// Looking at method wxHtmlWinParser::GetFontItalic
int retwxHtmlWinParserGetFontItalic0 = mywxHtmlWinParser->GetFontItalic();
// Looking at method wxHtmlWinParser::GetFontSize
int retwxHtmlWinParserGetFontSize0 = mywxHtmlWinParser->GetFontSize();
// Looking at method wxHtmlWinParser::GetFontUnderlined
int retwxHtmlWinParserGetFontUnderlined0 = mywxHtmlWinParser->GetFontUnderlined();
// Looking at method wxHtmlWinParser::GetInputEncoding
wxFontEncoding retwxHtmlWinParserGetInputEncoding0 = mywxHtmlWinParser->GetInputEncoding();
// Looking at method wxHtmlWinParser::GetLink
const wxHtmlLinkInfo retwxHtmlWinParserGetLink0 = mywxHtmlWinParser->GetLink();
// Looking at method wxHtmlWinParser::GetLinkColor
const wxColour retwxHtmlWinParserGetLinkColor0 = mywxHtmlWinParser->GetLinkColor();
// Looking at method wxHtmlWinParser::GetOutputEncoding
wxFontEncoding retwxHtmlWinParserGetOutputEncoding0 = mywxHtmlWinParser->GetOutputEncoding();
// Looking at method wxHtmlWinParser::GetWindow
wxHtmlWindow* retwxHtmlWinParserGetWindow0 = mywxHtmlWinParser->GetWindow();
// Looking at method wxHtmlWinParser::OpenContainer
wxHtmlContainerCell* retwxHtmlWinParserOpenContainer0 = mywxHtmlWinParser->OpenContainer();
// Looking at method wxHtmlWinParser::SetActualColor
wxColour  * wxHtmlWinParserSetActualColorclr0;
mywxHtmlWinParser->SetActualColor( * wxHtmlWinParserSetActualColorclr0);
// Looking at method wxHtmlWinParser::SetAlign
int  * wxHtmlWinParserSetAligna0;
mywxHtmlWinParser->SetAlign( * wxHtmlWinParserSetAligna0);
// Looking at method wxHtmlWinParser::SetContainer
wxHtmlContainerCell * * wxHtmlWinParserSetContainerc0;
wxHtmlContainerCell* retwxHtmlWinParserSetContainer0 = mywxHtmlWinParser->SetContainer( * wxHtmlWinParserSetContainerc0);
// Looking at method wxHtmlWinParser::SetDC
// Looking at method wxHtmlWinParser::SetFontBold
int  * wxHtmlWinParserSetFontBoldx0;
mywxHtmlWinParser->SetFontBold( * wxHtmlWinParserSetFontBoldx0);
// Looking at method wxHtmlWinParser::SetFontFace
wxString  * wxHtmlWinParserSetFontFaceface0;
mywxHtmlWinParser->SetFontFace( * wxHtmlWinParserSetFontFaceface0);
// Looking at method wxHtmlWinParser::SetFontFixed
int  * wxHtmlWinParserSetFontFixedx0;
mywxHtmlWinParser->SetFontFixed( * wxHtmlWinParserSetFontFixedx0);
// Looking at method wxHtmlWinParser::SetFontItalic
int  * wxHtmlWinParserSetFontItalicx0;
mywxHtmlWinParser->SetFontItalic( * wxHtmlWinParserSetFontItalicx0);
// Looking at method wxHtmlWinParser::SetFontSize
int  * wxHtmlWinParserSetFontSizes0;
mywxHtmlWinParser->SetFontSize( * wxHtmlWinParserSetFontSizes0);
// Looking at method wxHtmlWinParser::SetFontUnderlined
int  * wxHtmlWinParserSetFontUnderlinedx0;
mywxHtmlWinParser->SetFontUnderlined( * wxHtmlWinParserSetFontUnderlinedx0);
// Looking at method wxHtmlWinParser::SetFonts
wxString  * wxHtmlWinParserSetFontsnormal_face0;
wxString  * wxHtmlWinParserSetFontsfixed_face1;
int * * wxHtmlWinParserSetFontssizes2;
mywxHtmlWinParser->SetFonts( * wxHtmlWinParserSetFontsnormal_face0,  * wxHtmlWinParserSetFontsfixed_face1,  * wxHtmlWinParserSetFontssizes2);
// Looking at method wxHtmlWinParser::SetInputEncoding
wxFontEncoding  * wxHtmlWinParserSetInputEncodingenc0;
mywxHtmlWinParser->SetInputEncoding( * wxHtmlWinParserSetInputEncodingenc0);
// Looking at method wxHtmlWinParser::SetLink
wxHtmlLinkInfo  * wxHtmlWinParserSetLinklink0;
mywxHtmlWinParser->SetLink( * wxHtmlWinParserSetLinklink0);
// Looking at method wxHtmlWinParser::SetLinkColor
wxColour  * wxHtmlWinParserSetLinkColorclr0;
mywxHtmlWinParser->SetLinkColor( * wxHtmlWinParserSetLinkColorclr0);

// Looking at class wxHtmlWinTagHandler
wxHtmlWinTagHandler * mywxHtmlWinTagHandler;
// Looking at method wxHtmlWinTagHandler::m_WParser

// Looking at class wxIPV4address
wxIPV4address * mywxIPV4address;
// Looking at method wxIPV4address::Hostname
wxString  * wxIPV4addressHostnamehostname0;
bool retwxIPV4addressHostname0 = mywxIPV4address->Hostname( * wxIPV4addressHostnamehostname0);
wxString retwxIPV4addressHostname1 = mywxIPV4address->Hostname();
// Looking at method wxIPV4address::IPAddress
wxString retwxIPV4addressIPAddress0 = mywxIPV4address->IPAddress();
// Looking at method wxIPV4address::Service
wxString  * wxIPV4addressServiceservice0;
bool retwxIPV4addressService0 = mywxIPV4address->Service( * wxIPV4addressServiceservice0);
unsigned short  * wxIPV4addressServiceservice1;
bool retwxIPV4addressService1 = mywxIPV4address->Service( * wxIPV4addressServiceservice1);
unsigned short retwxIPV4addressService2 = mywxIPV4address->Service();
// Looking at method wxIPV4address::AnyAddress
bool retwxIPV4addressAnyAddress0 = mywxIPV4address->AnyAddress();
// Looking at method wxIPV4address::LocalHost
bool retwxIPV4addressLocalHost0 = mywxIPV4address->LocalHost();

// Looking at class wxIPaddress
wxIPaddress * mywxIPaddress;
// Looking at method wxIPaddress::Hostname
// Looking at method wxIPaddress::IPAddress
// Looking at method wxIPaddress::Service
// Looking at method wxIPaddress::AnyAddress
// Looking at method wxIPaddress::LocalHost
// Looking at method wxIPaddress::IsLocalHost

// Looking at class wxIcon
wxIcon * mywxIcon;
// Looking at method wxIcon::wxIcon
wxIcon * newwxIcon0 = new wxIcon();
wxIcon  * wxIconwxIconicon0;
wxIcon * newwxIcon1 = new wxIcon( * wxIconwxIconicon0);
void*  * wxIconwxIcondata1;
int  * wxIconwxIcontype2;
int  * wxIconwxIconwidth3;
int  * wxIconwxIconheight4;
int  * wxIconwxIcondepth5;
wxIcon * newwxIcon2 = new wxIcon( * wxIconwxIcondata1,  * wxIconwxIcontype2,  * wxIconwxIconwidth3,  * wxIconwxIconheight4,  * wxIconwxIcondepth5);
char  * * wxIconwxIconbitsptr6;
int  * wxIconwxIconwidth7;
int  * wxIconwxIconheight8;
int  * wxIconwxIcondepth9;
wxIcon * newwxIcon3 = new wxIcon( * wxIconwxIconbitsptr6,  * wxIconwxIconwidth7,  * wxIconwxIconheight8,  * wxIconwxIcondepth9);
int  * wxIconwxIconwidth10;
int  * wxIconwxIconheight11;
int  * wxIconwxIcondepth12;
wxIcon * newwxIcon4 = new wxIcon( * wxIconwxIconwidth10,  * wxIconwxIconheight11,  * wxIconwxIcondepth12);
char**  * wxIconwxIconbits13;
wxIcon * newwxIcon5 = new wxIcon( * wxIconwxIconbits13);
char**  * wxIconwxIconbits14;
wxIcon * newwxIcon6 = new wxIcon( * wxIconwxIconbits14);
wxString  * wxIconwxIconname15;
wxBitmapType  * wxIconwxIcontype16;
int  * wxIconwxIcondesiredWidth17;
int  * wxIconwxIcondesiredHeight18;
wxIcon * newwxIcon7 = new wxIcon( * wxIconwxIconname15,  * wxIconwxIcontype16,  * wxIconwxIcondesiredWidth17,  * wxIconwxIcondesiredHeight18);
wxIconLocation  * wxIconwxIconloc19;
wxIcon * newwxIcon8 = new wxIcon( * wxIconwxIconloc19);
// Looking at method wxIcon::CopyFromBitmap
wxBitmap  * wxIconCopyFromBitmapbmp0;
mywxIcon->CopyFromBitmap( * wxIconCopyFromBitmapbmp0);
// Looking at method wxIcon::GetDepth
int retwxIconGetDepth0 = mywxIcon->GetDepth();
// Looking at method wxIcon::GetHeight
int retwxIconGetHeight0 = mywxIcon->GetHeight();
// Looking at method wxIcon::GetWidth
int retwxIconGetWidth0 = mywxIcon->GetWidth();
// Looking at method wxIcon::LoadFile
wxString  * wxIconLoadFilename0;
wxBitmapType  * wxIconLoadFiletype1;
bool retwxIconLoadFile0 = mywxIcon->LoadFile( * wxIconLoadFilename0,  * wxIconLoadFiletype1);
// Looking at method wxIcon::Ok
bool retwxIconOk0 = mywxIcon->Ok();
// Looking at method wxIcon::SaveFile
wxString  * wxIconSaveFilename0;
wxBitmapType  * wxIconSaveFiletype1;
wxPalette*  * wxIconSaveFilepalette2;
bool retwxIconSaveFile0 = mywxIcon->SaveFile( * wxIconSaveFilename0,  * wxIconSaveFiletype1,  * wxIconSaveFilepalette2);
// Looking at method wxIcon::SetDepth
int  * wxIconSetDepthdepth0;
mywxIcon->SetDepth( * wxIconSetDepthdepth0);
// Looking at method wxIcon::SetHeight
int  * wxIconSetHeightheight0;
mywxIcon->SetHeight( * wxIconSetHeightheight0);
// Looking at method wxIcon::SetWidth
int  * wxIconSetWidthwidth0;
mywxIcon->SetWidth( * wxIconSetWidthwidth0);

// Looking at class wxIconBundle
wxIconBundle * mywxIconBundle;
// Looking at method wxIconBundle::wxIconBundle
wxIconBundle * newwxIconBundle0 = new wxIconBundle();
wxString  * wxIconBundlewxIconBundlefile0;
long  * wxIconBundlewxIconBundletype1;
wxIconBundle * newwxIconBundle1 = new wxIconBundle( * wxIconBundlewxIconBundlefile0,  * wxIconBundlewxIconBundletype1);
wxIcon  * wxIconBundlewxIconBundleicon2;
wxIconBundle * newwxIconBundle2 = new wxIconBundle( * wxIconBundlewxIconBundleicon2);
wxIconBundle  * wxIconBundlewxIconBundleic3;
wxIconBundle * newwxIconBundle3 = new wxIconBundle( * wxIconBundlewxIconBundleic3);
// Looking at method wxIconBundle::AddIcon
wxString  * wxIconBundleAddIconfile0;
long  * wxIconBundleAddIcontype1;
mywxIconBundle->AddIcon( * wxIconBundleAddIconfile0,  * wxIconBundleAddIcontype1);
wxIcon  * wxIconBundleAddIconicon2;
mywxIconBundle->AddIcon( * wxIconBundleAddIconicon2);
// Looking at method wxIconBundle::GetIcon
wxSize  * wxIconBundleGetIconsize0;
const wxIcon retwxIconBundleGetIcon0 = mywxIconBundle->GetIcon( * wxIconBundleGetIconsize0);
wxCoord  * wxIconBundleGetIconsize1;
const wxIcon retwxIconBundleGetIcon1 = mywxIconBundle->GetIcon( * wxIconBundleGetIconsize1);

// Looking at class wxIconLocation
wxIconLocation * mywxIconLocation;
// Looking at method wxIconLocation::IsOk
bool retwxIconLocationIsOk0 = mywxIconLocation->IsOk();

// Looking at class wxIconizeEvent
wxIconizeEvent * mywxIconizeEvent;
// Looking at method wxIconizeEvent::wxIconizeEvent
int  * wxIconizeEventwxIconizeEventid0;
bool  * wxIconizeEventwxIconizeEventiconized1;
wxIconizeEvent * newwxIconizeEvent0 = new wxIconizeEvent( * wxIconizeEventwxIconizeEventid0,  * wxIconizeEventwxIconizeEventiconized1);
// Looking at method wxIconizeEvent::Iconized
bool retwxIconizeEventIconized0 = mywxIconizeEvent->Iconized();

// Looking at class wxIdleEvent
wxIdleEvent * mywxIdleEvent;
// Looking at method wxIdleEvent::wxIdleEvent
wxIdleEvent * newwxIdleEvent0 = new wxIdleEvent();
// Looking at method wxIdleEvent::CanSend
wxWindow*  * wxIdleEventCanSendwindow0;
static bool retwxIdleEventCanSend0 = mywxIdleEvent->CanSend( * wxIdleEventCanSendwindow0);
// Looking at method wxIdleEvent::GetMode
static wxIdleMode retwxIdleEventGetMode0 = mywxIdleEvent->GetMode();
// Looking at method wxIdleEvent::RequestMore
bool  * wxIdleEventRequestMoreneedMore0;
mywxIdleEvent->RequestMore( * wxIdleEventRequestMoreneedMore0);
// Looking at method wxIdleEvent::MoreRequested
bool retwxIdleEventMoreRequested0 = mywxIdleEvent->MoreRequested();
// Looking at method wxIdleEvent::SetMode
wxIdleMode  * wxIdleEventSetModemode0;
mywxIdleEvent->SetMode( * wxIdleEventSetModemode0);

// Looking at class wxImage
wxImage * mywxImage;
// Looking at method wxImage::wxImage
wxImage * newwxImage0 = new wxImage();
wxImage  * wxImagewxImageimage0;
wxImage * newwxImage1 = new wxImage( * wxImagewxImageimage0);
int  * wxImagewxImagewidth1;
int  * wxImagewxImageheight2;
bool  * wxImagewxImageclear3;
wxImage * newwxImage2 = new wxImage( * wxImagewxImagewidth1,  * wxImagewxImageheight2,  * wxImagewxImageclear3);
int  * wxImagewxImagewidth4;
int  * wxImagewxImageheight5;
unsigned char*  * wxImagewxImagedata6;
bool  * wxImagewxImagestatic_data7;
wxImage * newwxImage3 = new wxImage( * wxImagewxImagewidth4,  * wxImagewxImageheight5,  * wxImagewxImagedata6,  * wxImagewxImagestatic_data7);
wxString  * wxImagewxImagename8;
long  * wxImagewxImagetype9;
int  * wxImagewxImageindex10;
wxImage * newwxImage4 = new wxImage( * wxImagewxImagename8,  * wxImagewxImagetype9,  * wxImagewxImageindex10);
wxString  * wxImagewxImagename11;
wxString  * wxImagewxImagemimetype12;
int  * wxImagewxImageindex13;
wxImage * newwxImage5 = new wxImage( * wxImagewxImagename11,  * wxImagewxImagemimetype12,  * wxImagewxImageindex13);
wxInputStream  * wxImagewxImagestream14;
long  * wxImagewxImagetype15;
int  * wxImagewxImageindex16;
wxImage * newwxImage6 = new wxImage( * wxImagewxImagestream14,  * wxImagewxImagetype15,  * wxImagewxImageindex16);
wxInputStream  * wxImagewxImagestream17;
wxString  * wxImagewxImagemimetype18;
int  * wxImagewxImageindex19;
wxImage * newwxImage7 = new wxImage( * wxImagewxImagestream17,  * wxImagewxImagemimetype18,  * wxImagewxImageindex19);
// Looking at method wxImage::AddHandler
wxImageHandler*  * wxImageAddHandlerhandler0;
mywxImage->AddHandler( * wxImageAddHandlerhandler0);
wxString  * wxImageCanReadfilename1;
bool retwxImageCanRead1 = mywxImage->CanRead( * wxImageCanReadfilename1);
// Looking at method wxImage::CleanUpHandlers
mywxImage->CleanUpHandlers();
// Looking at method wxImage::ComputeHistogram
wxImageHistogram  * wxImageComputeHistogramhistogram0;
unsigned long retwxImageComputeHistogram0 = mywxImage->ComputeHistogram( * wxImageComputeHistogramhistogram0);
// Looking at method wxImage::ConvertAlphaToMask
unsigned char  * wxImageConvertAlphaToMaskthreshold0;
bool retwxImageConvertAlphaToMask0 = mywxImage->ConvertAlphaToMask( * wxImageConvertAlphaToMaskthreshold0);
// Looking at method wxImage::ConvertToMono
unsigned char  * wxImageConvertToMonor0;
unsigned char  * wxImageConvertToMonog1;
unsigned char  * wxImageConvertToMonob2;
wxImage retwxImageConvertToMono0 = mywxImage->ConvertToMono( * wxImageConvertToMonor0,  * wxImageConvertToMonog1,  * wxImageConvertToMonob2);
// Looking at method wxImage::Copy
wxImage retwxImageCopy0 = mywxImage->Copy();
// Looking at method wxImage::Create
int  * wxImageCreatewidth0;
int  * wxImageCreateheight1;
bool  * wxImageCreateclear2;
bool retwxImageCreate0 = mywxImage->Create( * wxImageCreatewidth0,  * wxImageCreateheight1,  * wxImageCreateclear2);
// Looking at method wxImage::Destroy
mywxImage->Destroy();
// Looking at method wxImage::FindFirstUnusedColour
unsigned char *  * wxImageFindFirstUnusedColourr0;
unsigned char *  * wxImageFindFirstUnusedColourg1;
unsigned char *  * wxImageFindFirstUnusedColourb2;
unsigned char  * wxImageFindFirstUnusedColourstartR3;
unsigned char  * wxImageFindFirstUnusedColourstartG4;
unsigned char  * wxImageFindFirstUnusedColourstartB5;
bool retwxImageFindFirstUnusedColour0 = mywxImage->FindFirstUnusedColour( * wxImageFindFirstUnusedColourr0,  * wxImageFindFirstUnusedColourg1,  * wxImageFindFirstUnusedColourb2,  * wxImageFindFirstUnusedColourstartR3,  * wxImageFindFirstUnusedColourstartG4,  * wxImageFindFirstUnusedColourstartB5);
// Looking at method wxImage::FindHandler
wxString  * wxImageFindHandlername0;
static wxImageHandler* retwxImageFindHandler0 = mywxImage->FindHandler( * wxImageFindHandlername0);
wxString  * wxImageFindHandlerextension1;
long  * wxImageFindHandlerimageType2;
static wxImageHandler* retwxImageFindHandler1 = mywxImage->FindHandler( * wxImageFindHandlerextension1,  * wxImageFindHandlerimageType2);
long  * wxImageFindHandlerimageType3;
static wxImageHandler* retwxImageFindHandler2 = mywxImage->FindHandler( * wxImageFindHandlerimageType3);
wxString  * wxImageFindHandlerMimemimetype4;
static wxImageHandler* retwxImageFindHandlerMime3 = mywxImage->FindHandlerMime( * wxImageFindHandlerMimemimetype4);
// Looking at method wxImage::GetImageExtWildcard
static wxString retwxImageGetImageExtWildcard0 = mywxImage->GetImageExtWildcard();
// Looking at method wxImage::GetAlpha
int  * wxImageGetAlphax0;
int  * wxImageGetAlphay1;
unsigned char retwxImageGetAlpha0 = mywxImage->GetAlpha( * wxImageGetAlphax0,  * wxImageGetAlphay1);
unsigned char * retwxImageGetAlpha1 = mywxImage->GetAlpha();
// Looking at method wxImage::GetBlue
int  * wxImageGetBluex0;
int  * wxImageGetBluey1;
unsigned char retwxImageGetBlue0 = mywxImage->GetBlue( * wxImageGetBluex0,  * wxImageGetBluey1);
// Looking at method wxImage::GetData
unsigned char* retwxImageGetData0 = mywxImage->GetData();
// Looking at method wxImage::GetGreen
int  * wxImageGetGreenx0;
int  * wxImageGetGreeny1;
unsigned char retwxImageGetGreen0 = mywxImage->GetGreen( * wxImageGetGreenx0,  * wxImageGetGreeny1);
// Looking at method wxImage::GetImageCount
wxString  * wxImageGetImageCountfilename0;
long  * wxImageGetImageCounttype1;
static int retwxImageGetImageCount0 = mywxImage->GetImageCount( * wxImageGetImageCountfilename0,  * wxImageGetImageCounttype1);
wxInputStream  * wxImageGetImageCountstream2;
long  * wxImageGetImageCounttype3;
static int retwxImageGetImageCount1 = mywxImage->GetImageCount( * wxImageGetImageCountstream2,  * wxImageGetImageCounttype3);
// Looking at method wxImage::GetHandlers
static wxList retwxImageGetHandlers0 = mywxImage->GetHandlers();
// Looking at method wxImage::GetHeight
int retwxImageGetHeight0 = mywxImage->GetHeight();
// Looking at method wxImage::GetMaskBlue
unsigned char retwxImageGetMaskBlue0 = mywxImage->GetMaskBlue();
// Looking at method wxImage::GetMaskGreen
unsigned char retwxImageGetMaskGreen0 = mywxImage->GetMaskGreen();
// Looking at method wxImage::GetMaskRed
unsigned char retwxImageGetMaskRed0 = mywxImage->GetMaskRed();
// Looking at method wxImage::GetPalette
const wxPalette retwxImageGetPalette0 = mywxImage->GetPalette();
// Looking at method wxImage::GetRed
int  * wxImageGetRedx0;
int  * wxImageGetRedy1;
unsigned char retwxImageGetRed0 = mywxImage->GetRed( * wxImageGetRedx0,  * wxImageGetRedy1);
// Looking at method wxImage::GetSubImage
wxRect  * wxImageGetSubImagerect0;
wxImage retwxImageGetSubImage0 = mywxImage->GetSubImage( * wxImageGetSubImagerect0);
// Looking at method wxImage::GetWidth
int retwxImageGetWidth0 = mywxImage->GetWidth();
// Looking at method wxImage::HasAlpha
bool retwxImageHasAlpha0 = mywxImage->HasAlpha();
// Looking at method wxImage::HasMask
bool retwxImageHasMask0 = mywxImage->HasMask();
// Looking at method wxImage::GetOption
wxString  * wxImageGetOptionname0;
wxString retwxImageGetOption0 = mywxImage->GetOption( * wxImageGetOptionname0);
// Looking at method wxImage::GetOptionInt
wxString  * wxImageGetOptionIntname0;
int retwxImageGetOptionInt0 = mywxImage->GetOptionInt( * wxImageGetOptionIntname0);
// Looking at method wxImage::HasOption
wxString  * wxImageHasOptionname0;
bool retwxImageHasOption0 = mywxImage->HasOption( * wxImageHasOptionname0);
// Looking at method wxImage::InitAlpha
mywxImage->InitAlpha();
// Looking at method wxImage::InitStandardHandlers
mywxImage->InitStandardHandlers();
// Looking at method wxImage::InsertHandler
wxImageHandler*  * wxImageInsertHandlerhandler0;
mywxImage->InsertHandler( * wxImageInsertHandlerhandler0);
// Looking at method wxImage::LoadFile
wxString  * wxImageLoadFilename0;
long  * wxImageLoadFiletype1;
int  * wxImageLoadFileindex2;
bool retwxImageLoadFile0 = mywxImage->LoadFile( * wxImageLoadFilename0,  * wxImageLoadFiletype1,  * wxImageLoadFileindex2);
wxString  * wxImageLoadFilename3;
wxString  * wxImageLoadFilemimetype4;
int  * wxImageLoadFileindex5;
bool retwxImageLoadFile1 = mywxImage->LoadFile( * wxImageLoadFilename3,  * wxImageLoadFilemimetype4,  * wxImageLoadFileindex5);
wxInputStream  * wxImageLoadFilestream6;
long  * wxImageLoadFiletype7;
int  * wxImageLoadFileindex8;
bool retwxImageLoadFile2 = mywxImage->LoadFile( * wxImageLoadFilestream6,  * wxImageLoadFiletype7,  * wxImageLoadFileindex8);
wxInputStream  * wxImageLoadFilestream9;
wxString  * wxImageLoadFilemimetype10;
int  * wxImageLoadFileindex11;
bool retwxImageLoadFile3 = mywxImage->LoadFile( * wxImageLoadFilestream9,  * wxImageLoadFilemimetype10,  * wxImageLoadFileindex11);
// Looking at method wxImage::Ok
bool retwxImageOk0 = mywxImage->Ok();
// Looking at method wxImage::RemoveHandler
wxString  * wxImageRemoveHandlername0;
static bool retwxImageRemoveHandler0 = mywxImage->RemoveHandler( * wxImageRemoveHandlername0);
// Looking at method wxImage::Mirror
bool  * wxImageMirrorhorizontally0;
wxImage retwxImageMirror0 = mywxImage->Mirror( * wxImageMirrorhorizontally0);
// Looking at method wxImage::Replace
unsigned char  * wxImageReplacer10;
unsigned char  * wxImageReplaceg11;
unsigned char  * wxImageReplaceb12;
unsigned char  * wxImageReplacer23;
unsigned char  * wxImageReplaceg24;
unsigned char  * wxImageReplaceb25;
mywxImage->Replace( * wxImageReplacer10,  * wxImageReplaceg11,  * wxImageReplaceb12,  * wxImageReplacer23,  * wxImageReplaceg24,  * wxImageReplaceb25);
// Looking at method wxImage::Rescale
int  * wxImageRescalewidth0;
int  * wxImageRescaleheight1;
wxImage  retwxImageRescale0 = mywxImage->Rescale( * wxImageRescalewidth0,  * wxImageRescaleheight1);
// Looking at method wxImage::Rotate
double  * wxImageRotateangle0;
wxPoint  * wxImageRotaterotationCentre1;
bool  * wxImageRotateinterpolating2;
wxPoint*  * wxImageRotateoffsetAfterRotation3;
wxImage retwxImageRotate0 = mywxImage->Rotate( * wxImageRotateangle0,  * wxImageRotaterotationCentre1,  * wxImageRotateinterpolating2,  * wxImageRotateoffsetAfterRotation3);
// Looking at method wxImage::Rotate90
bool  * wxImageRotate90clockwise0;
wxImage retwxImageRotate900 = mywxImage->Rotate90( * wxImageRotate90clockwise0);
// Looking at method wxImage::SaveFile
wxString  * wxImageSaveFilename0;
int  * wxImageSaveFiletype1;
bool retwxImageSaveFile0 = mywxImage->SaveFile( * wxImageSaveFilename0,  * wxImageSaveFiletype1);
wxString  * wxImageSaveFilename2;
wxString  * wxImageSaveFilemimetype3;
bool retwxImageSaveFile1 = mywxImage->SaveFile( * wxImageSaveFilename2,  * wxImageSaveFilemimetype3);
wxString  * wxImageSaveFilename4;
bool retwxImageSaveFile2 = mywxImage->SaveFile( * wxImageSaveFilename4);
wxOutputStream  * wxImageSaveFilestream5;
int  * wxImageSaveFiletype6;
bool retwxImageSaveFile3 = mywxImage->SaveFile( * wxImageSaveFilestream5,  * wxImageSaveFiletype6);
wxOutputStream  * wxImageSaveFilestream7;
wxString  * wxImageSaveFilemimetype8;
bool retwxImageSaveFile4 = mywxImage->SaveFile( * wxImageSaveFilestream7,  * wxImageSaveFilemimetype8);
// Looking at method wxImage::Scale
int  * wxImageScalewidth0;
int  * wxImageScaleheight1;
wxImage retwxImageScale0 = mywxImage->Scale( * wxImageScalewidth0,  * wxImageScaleheight1);
// Looking at method wxImage::SetAlpha
unsigned char * * wxImageSetAlphaalpha0;
mywxImage->SetAlpha( * wxImageSetAlphaalpha0);
int  * wxImageSetAlphax1;
int  * wxImageSetAlphay2;
unsigned char  * wxImageSetAlphaalpha3;
mywxImage->SetAlpha( * wxImageSetAlphax1,  * wxImageSetAlphay2,  * wxImageSetAlphaalpha3);
// Looking at method wxImage::SetData
unsigned char* * wxImageSetDatadata0;
mywxImage->SetData( * wxImageSetDatadata0);
// Looking at method wxImage::SetMask
bool  * wxImageSetMaskhasMask0;
mywxImage->SetMask( * wxImageSetMaskhasMask0);
// Looking at method wxImage::SetMaskColour
unsigned char  * wxImageSetMaskColourred0;
unsigned char  * wxImageSetMaskColourgreen1;
unsigned char  * wxImageSetMaskColourblue2;
mywxImage->SetMaskColour( * wxImageSetMaskColourred0,  * wxImageSetMaskColourgreen1,  * wxImageSetMaskColourblue2);
// Looking at method wxImage::SetMaskFromImage
wxImage  * wxImageSetMaskFromImagemask0;
unsigned char  * wxImageSetMaskFromImagemr1;
unsigned char  * wxImageSetMaskFromImagemg2;
unsigned char  * wxImageSetMaskFromImagemb3;
bool retwxImageSetMaskFromImage0 = mywxImage->SetMaskFromImage( * wxImageSetMaskFromImagemask0,  * wxImageSetMaskFromImagemr1,  * wxImageSetMaskFromImagemg2,  * wxImageSetMaskFromImagemb3);
// Looking at method wxImage::SetOption
wxString  * wxImageSetOptionname0;
wxString  * wxImageSetOptionvalue1;
mywxImage->SetOption( * wxImageSetOptionname0,  * wxImageSetOptionvalue1);
wxString  * wxImageSetOptionname2;
int  * wxImageSetOptionvalue3;
mywxImage->SetOption( * wxImageSetOptionname2,  * wxImageSetOptionvalue3);
// Looking at method wxImage::SetPalette
wxPalette  * wxImageSetPalettepalette0;
mywxImage->SetPalette( * wxImageSetPalettepalette0);
// Looking at method wxImage::SetRGB
int  * wxImageSetRGBx0;
int  * wxImageSetRGBy1;
unsigned char  * wxImageSetRGBred2;
unsigned char  * wxImageSetRGBgreen3;
unsigned char  * wxImageSetRGBblue4;
mywxImage->SetRGB( * wxImageSetRGBx0,  * wxImageSetRGBy1,  * wxImageSetRGBred2,  * wxImageSetRGBgreen3,  * wxImageSetRGBblue4);

// Looking at class wxImageList
wxImageList * mywxImageList;
// Looking at method wxImageList::wxImageList
wxImageList * newwxImageList0 = new wxImageList();
int  * wxImageListwxImageListwidth0;
int  * wxImageListwxImageListheight1;
bool  * wxImageListwxImageListmask2;
int  * wxImageListwxImageListinitialCount3;
wxImageList * newwxImageList1 = new wxImageList( * wxImageListwxImageListwidth0,  * wxImageListwxImageListheight1,  * wxImageListwxImageListmask2,  * wxImageListwxImageListinitialCount3);
// Looking at method wxImageList::Add
wxBitmap  * wxImageListAddbitmap0;
wxBitmap  * wxImageListAddmask1;
int retwxImageListAdd0 = mywxImageList->Add( * wxImageListAddbitmap0,  * wxImageListAddmask1);
wxBitmap  * wxImageListAddbitmap2;
wxColour  * wxImageListAddmaskColour3;
int retwxImageListAdd1 = mywxImageList->Add( * wxImageListAddbitmap2,  * wxImageListAddmaskColour3);
wxIcon  * wxImageListAddicon4;
int retwxImageListAdd2 = mywxImageList->Add( * wxImageListAddicon4);
// Looking at method wxImageList::Create
int  * wxImageListCreatewidth0;
int  * wxImageListCreateheight1;
bool  * wxImageListCreatemask2;
int  * wxImageListCreateinitialCount3;
bool retwxImageListCreate0 = mywxImageList->Create( * wxImageListCreatewidth0,  * wxImageListCreateheight1,  * wxImageListCreatemask2,  * wxImageListCreateinitialCount3);
// Looking at method wxImageList::Draw
int  * wxImageListDrawindex0;
wxDC  * wxImageListDrawdc1;
int  * wxImageListDrawx2;
int  * wxImageListDrawx3;
int  * wxImageListDrawflags4;
bool  * wxImageListDrawsolidBackground5;
bool retwxImageListDraw0 = mywxImageList->Draw( * wxImageListDrawindex0,  * wxImageListDrawdc1,  * wxImageListDrawx2,  * wxImageListDrawx3,  * wxImageListDrawflags4,  * wxImageListDrawsolidBackground5);
// Looking at method wxImageList::GetImageCount
int retwxImageListGetImageCount0 = mywxImageList->GetImageCount();
// Looking at method wxImageList::GetSize
int  * wxImageListGetSizeindex0;
int  * wxImageListGetSizewidth1;
int  * wxImageListGetSizeheight2;
bool retwxImageListGetSize0 = mywxImageList->GetSize( * wxImageListGetSizeindex0,  * wxImageListGetSizewidth1,  * wxImageListGetSizeheight2);
// Looking at method wxImageList::Remove
int  * wxImageListRemoveindex0;
bool retwxImageListRemove0 = mywxImageList->Remove( * wxImageListRemoveindex0);
// Looking at method wxImageList::RemoveAll
bool retwxImageListRemoveAll0 = mywxImageList->RemoveAll();
// Looking at method wxImageList::Replace
int  * wxImageListReplaceindex0;
wxBitmap  * wxImageListReplacebitmap1;
wxBitmap  * wxImageListReplacemask2;
bool retwxImageListReplace0 = mywxImageList->Replace( * wxImageListReplaceindex0,  * wxImageListReplacebitmap1,  * wxImageListReplacemask2);
int  * wxImageListReplaceindex3;
wxIcon  * wxImageListReplaceicon4;
bool retwxImageListReplace1 = mywxImageList->Replace( * wxImageListReplaceindex3,  * wxImageListReplaceicon4);

// Looking at class wxIndividualLayoutConstraint
wxIndividualLayoutConstraint * mywxIndividualLayoutConstraint;
// Looking at method wxIndividualLayoutConstraint::wxIndividualLayoutConstraint
wxIndividualLayoutConstraint * newwxIndividualLayoutConstraint0 = new wxIndividualLayoutConstraint();
// Looking at method wxIndividualLayoutConstraint::Above
wxWindow * * wxIndividualLayoutConstraintAboveotherWin0;
int  * wxIndividualLayoutConstraintAbovemargin1;
mywxIndividualLayoutConstraint->Above( * wxIndividualLayoutConstraintAboveotherWin0,  * wxIndividualLayoutConstraintAbovemargin1);
// Looking at method wxIndividualLayoutConstraint::Absolute
int  * wxIndividualLayoutConstraintAbsolutevalue0;
mywxIndividualLayoutConstraint->Absolute( * wxIndividualLayoutConstraintAbsolutevalue0);
// Looking at method wxIndividualLayoutConstraint::AsIs
mywxIndividualLayoutConstraint->AsIs();
// Looking at method wxIndividualLayoutConstraint::Below
wxWindow * * wxIndividualLayoutConstraintBelowotherWin0;
int  * wxIndividualLayoutConstraintBelowmargin1;
mywxIndividualLayoutConstraint->Below( * wxIndividualLayoutConstraintBelowotherWin0,  * wxIndividualLayoutConstraintBelowmargin1);
// Looking at method wxIndividualLayoutConstraint::Unconstrained
mywxIndividualLayoutConstraint->Unconstrained();
// Looking at method wxIndividualLayoutConstraint::LeftOf
wxWindow * * wxIndividualLayoutConstraintLeftOfotherWin0;
int  * wxIndividualLayoutConstraintLeftOfmargin1;
mywxIndividualLayoutConstraint->LeftOf( * wxIndividualLayoutConstraintLeftOfotherWin0,  * wxIndividualLayoutConstraintLeftOfmargin1);
// Looking at method wxIndividualLayoutConstraint::PercentOf
wxWindow * * wxIndividualLayoutConstraintPercentOfotherWin0;
wxEdge  * wxIndividualLayoutConstraintPercentOfedge1;
int  * wxIndividualLayoutConstraintPercentOfper2;
mywxIndividualLayoutConstraint->PercentOf( * wxIndividualLayoutConstraintPercentOfotherWin0,  * wxIndividualLayoutConstraintPercentOfedge1,  * wxIndividualLayoutConstraintPercentOfper2);
// Looking at method wxIndividualLayoutConstraint::RightOf
wxWindow * * wxIndividualLayoutConstraintRightOfotherWin0;
int  * wxIndividualLayoutConstraintRightOfmargin1;
mywxIndividualLayoutConstraint->RightOf( * wxIndividualLayoutConstraintRightOfotherWin0,  * wxIndividualLayoutConstraintRightOfmargin1);
// Looking at method wxIndividualLayoutConstraint::SameAs
wxWindow * * wxIndividualLayoutConstraintSameAsotherWin0;
wxEdge  * wxIndividualLayoutConstraintSameAsedge1;
int  * wxIndividualLayoutConstraintSameAsmargin2;
mywxIndividualLayoutConstraint->SameAs( * wxIndividualLayoutConstraintSameAsotherWin0,  * wxIndividualLayoutConstraintSameAsedge1,  * wxIndividualLayoutConstraintSameAsmargin2);
// Looking at method wxIndividualLayoutConstraint::Set
wxRelationship  * wxIndividualLayoutConstraintSetrel0;
wxWindow * * wxIndividualLayoutConstraintSetotherWin1;
wxEdge  * wxIndividualLayoutConstraintSetotherEdge2;
int  * wxIndividualLayoutConstraintSetvalue3;
int  * wxIndividualLayoutConstraintSetmargin4;
mywxIndividualLayoutConstraint->Set( * wxIndividualLayoutConstraintSetrel0,  * wxIndividualLayoutConstraintSetotherWin1,  * wxIndividualLayoutConstraintSetotherEdge2,  * wxIndividualLayoutConstraintSetvalue3,  * wxIndividualLayoutConstraintSetmargin4);

// Looking at class wxInitDialogEvent
wxInitDialogEvent * mywxInitDialogEvent;
// Looking at method wxInitDialogEvent::wxInitDialogEvent
int  * wxInitDialogEventwxInitDialogEventid0;
wxInitDialogEvent * newwxInitDialogEvent0 = new wxInitDialogEvent( * wxInitDialogEventwxInitDialogEventid0);

// Looking at class wxJoystick
wxJoystick * mywxJoystick;
// Looking at method wxJoystick::wxJoystick
int  * wxJoystickwxJoystickjoystick0;
wxJoystick * newwxJoystick0 = new wxJoystick( * wxJoystickwxJoystickjoystick0);
// Looking at method wxJoystick::GetButtonState
int retwxJoystickGetButtonState0 = mywxJoystick->GetButtonState();
// Looking at method wxJoystick::GetManufacturerId
int retwxJoystickGetManufacturerId0 = mywxJoystick->GetManufacturerId();
// Looking at method wxJoystick::GetMovementThreshold
int retwxJoystickGetMovementThreshold0 = mywxJoystick->GetMovementThreshold();
// Looking at method wxJoystick::GetNumberAxes
int retwxJoystickGetNumberAxes0 = mywxJoystick->GetNumberAxes();
// Looking at method wxJoystick::GetNumberButtons
int retwxJoystickGetNumberButtons0 = mywxJoystick->GetNumberButtons();
// Looking at method wxJoystick::GetNumberJoysticks
int retwxJoystickGetNumberJoysticks0 = mywxJoystick->GetNumberJoysticks();
// Looking at method wxJoystick::GetPollingMax
int retwxJoystickGetPollingMax0 = mywxJoystick->GetPollingMax();
// Looking at method wxJoystick::GetPollingMin
int retwxJoystickGetPollingMin0 = mywxJoystick->GetPollingMin();
// Looking at method wxJoystick::GetProductId
int retwxJoystickGetProductId0 = mywxJoystick->GetProductId();
// Looking at method wxJoystick::GetProductName
wxString retwxJoystickGetProductName0 = mywxJoystick->GetProductName();
// Looking at method wxJoystick::GetPosition
wxPoint retwxJoystickGetPosition0 = mywxJoystick->GetPosition();
// Looking at method wxJoystick::GetPOVPosition
int retwxJoystickGetPOVPosition0 = mywxJoystick->GetPOVPosition();
// Looking at method wxJoystick::GetPOVCTSPosition
int retwxJoystickGetPOVCTSPosition0 = mywxJoystick->GetPOVCTSPosition();
// Looking at method wxJoystick::GetRudderMax
int retwxJoystickGetRudderMax0 = mywxJoystick->GetRudderMax();
// Looking at method wxJoystick::GetRudderMin
int retwxJoystickGetRudderMin0 = mywxJoystick->GetRudderMin();
// Looking at method wxJoystick::GetRudderPosition
int retwxJoystickGetRudderPosition0 = mywxJoystick->GetRudderPosition();
// Looking at method wxJoystick::GetUMax
int retwxJoystickGetUMax0 = mywxJoystick->GetUMax();
// Looking at method wxJoystick::GetUMin
int retwxJoystickGetUMin0 = mywxJoystick->GetUMin();
// Looking at method wxJoystick::GetUPosition
int retwxJoystickGetUPosition0 = mywxJoystick->GetUPosition();
// Looking at method wxJoystick::GetVMax
int retwxJoystickGetVMax0 = mywxJoystick->GetVMax();
// Looking at method wxJoystick::GetVMin
int retwxJoystickGetVMin0 = mywxJoystick->GetVMin();
// Looking at method wxJoystick::GetVPosition
int retwxJoystickGetVPosition0 = mywxJoystick->GetVPosition();
// Looking at method wxJoystick::GetXMax
int retwxJoystickGetXMax0 = mywxJoystick->GetXMax();
// Looking at method wxJoystick::GetXMin
int retwxJoystickGetXMin0 = mywxJoystick->GetXMin();
// Looking at method wxJoystick::GetYMax
int retwxJoystickGetYMax0 = mywxJoystick->GetYMax();
// Looking at method wxJoystick::GetYMin
int retwxJoystickGetYMin0 = mywxJoystick->GetYMin();
// Looking at method wxJoystick::GetZMax
int retwxJoystickGetZMax0 = mywxJoystick->GetZMax();
// Looking at method wxJoystick::GetZMin
int retwxJoystickGetZMin0 = mywxJoystick->GetZMin();
// Looking at method wxJoystick::GetZPosition
int retwxJoystickGetZPosition0 = mywxJoystick->GetZPosition();
// Looking at method wxJoystick::HasPOV
bool retwxJoystickHasPOV0 = mywxJoystick->HasPOV();
// Looking at method wxJoystick::HasPOV4Dir
bool retwxJoystickHasPOV4Dir0 = mywxJoystick->HasPOV4Dir();
// Looking at method wxJoystick::HasPOVCTS
bool retwxJoystickHasPOVCTS0 = mywxJoystick->HasPOVCTS();
// Looking at method wxJoystick::HasRudder
bool retwxJoystickHasRudder0 = mywxJoystick->HasRudder();
// Looking at method wxJoystick::HasU
bool retwxJoystickHasU0 = mywxJoystick->HasU();
// Looking at method wxJoystick::HasV
bool retwxJoystickHasV0 = mywxJoystick->HasV();
// Looking at method wxJoystick::HasZ
bool retwxJoystickHasZ0 = mywxJoystick->HasZ();
// Looking at method wxJoystick::IsOk
bool retwxJoystickIsOk0 = mywxJoystick->IsOk();
// Looking at method wxJoystick::ReleaseCapture
bool retwxJoystickReleaseCapture0 = mywxJoystick->ReleaseCapture();
// Looking at method wxJoystick::SetCapture
wxWindow*  * wxJoystickSetCapturewin0;
int  * wxJoystickSetCapturepollingFreq1;
bool retwxJoystickSetCapture0 = mywxJoystick->SetCapture( * wxJoystickSetCapturewin0,  * wxJoystickSetCapturepollingFreq1);
// Looking at method wxJoystick::SetMovementThreshold
int  * wxJoystickSetMovementThresholdthreshold0;
mywxJoystick->SetMovementThreshold( * wxJoystickSetMovementThresholdthreshold0);

// Looking at class wxJoystickEvent
wxJoystickEvent * mywxJoystickEvent;
// Looking at method wxJoystickEvent::wxJoystickEvent
WXTYPE  * wxJoystickEventwxJoystickEventeventType0;
int  * wxJoystickEventwxJoystickEventstate1;
int  * wxJoystickEventwxJoystickEventjoystick2;
int  * wxJoystickEventwxJoystickEventchange3;
wxJoystickEvent * newwxJoystickEvent0 = new wxJoystickEvent( * wxJoystickEventwxJoystickEventeventType0,  * wxJoystickEventwxJoystickEventstate1,  * wxJoystickEventwxJoystickEventjoystick2,  * wxJoystickEventwxJoystickEventchange3);
// Looking at method wxJoystickEvent::ButtonDown
int  * wxJoystickEventButtonDownbutton0;
bool retwxJoystickEventButtonDown0 = mywxJoystickEvent->ButtonDown( * wxJoystickEventButtonDownbutton0);
// Looking at method wxJoystickEvent::ButtonIsDown
int  * wxJoystickEventButtonIsDownbutton0;
bool retwxJoystickEventButtonIsDown0 = mywxJoystickEvent->ButtonIsDown( * wxJoystickEventButtonIsDownbutton0);
// Looking at method wxJoystickEvent::ButtonUp
int  * wxJoystickEventButtonUpbutton0;
bool retwxJoystickEventButtonUp0 = mywxJoystickEvent->ButtonUp( * wxJoystickEventButtonUpbutton0);
// Looking at method wxJoystickEvent::GetButtonChange
int retwxJoystickEventGetButtonChange0 = mywxJoystickEvent->GetButtonChange();
// Looking at method wxJoystickEvent::GetButtonState
int retwxJoystickEventGetButtonState0 = mywxJoystickEvent->GetButtonState();
// Looking at method wxJoystickEvent::GetJoystick
int retwxJoystickEventGetJoystick0 = mywxJoystickEvent->GetJoystick();
// Looking at method wxJoystickEvent::GetPosition
wxPoint retwxJoystickEventGetPosition0 = mywxJoystickEvent->GetPosition();
// Looking at method wxJoystickEvent::GetZPosition
int retwxJoystickEventGetZPosition0 = mywxJoystickEvent->GetZPosition();
// Looking at method wxJoystickEvent::IsButton
bool retwxJoystickEventIsButton0 = mywxJoystickEvent->IsButton();
// Looking at method wxJoystickEvent::IsMove
bool retwxJoystickEventIsMove0 = mywxJoystickEvent->IsMove();
// Looking at method wxJoystickEvent::IsZMove
bool retwxJoystickEventIsZMove0 = mywxJoystickEvent->IsZMove();

// Looking at class wxKeyEvent
wxKeyEvent * mywxKeyEvent;
// Looking at method wxKeyEvent::m_altDown
// Looking at method wxKeyEvent::m_controlDown
// Looking at method wxKeyEvent::m_keyCode
// Looking at method wxKeyEvent::m_metaDown
// Looking at method wxKeyEvent::m_shiftDown
// Looking at method wxKeyEvent::m_x
// Looking at method wxKeyEvent::m_y
// Looking at method wxKeyEvent::wxKeyEvent
WXTYPE  * wxKeyEventwxKeyEventkeyEventType0;
wxKeyEvent * newwxKeyEvent0 = new wxKeyEvent( * wxKeyEventwxKeyEventkeyEventType0);
// Looking at method wxKeyEvent::AltDown
bool retwxKeyEventAltDown0 = mywxKeyEvent->AltDown();
// Looking at method wxKeyEvent::CmdDown
bool retwxKeyEventCmdDown0 = mywxKeyEvent->CmdDown();
// Looking at method wxKeyEvent::ControlDown
bool retwxKeyEventControlDown0 = mywxKeyEvent->ControlDown();
// Looking at method wxKeyEvent::GetKeyCode
int retwxKeyEventGetKeyCode0 = mywxKeyEvent->GetKeyCode();
// Looking at method wxKeyEvent::GetPosition
wxPoint retwxKeyEventGetPosition0 = mywxKeyEvent->GetPosition();
long * * wxKeyEventGetPositionx0;
long * * wxKeyEventGetPositiony1;
mywxKeyEvent->GetPosition( * wxKeyEventGetPositionx0,  * wxKeyEventGetPositiony1);
// Looking at method wxKeyEvent::GetRawKeyCode
wxUint32 retwxKeyEventGetRawKeyCode0 = mywxKeyEvent->GetRawKeyCode();
// Looking at method wxKeyEvent::GetRawKeyFlags
wxUint32 retwxKeyEventGetRawKeyFlags0 = mywxKeyEvent->GetRawKeyFlags();
// Looking at method wxKeyEvent::GetUnicodeKey
#if wxUSE_UNICODE == 1
wxChar retwxKeyEventGetUnicodeKey0 = mywxKeyEvent->GetUnicodeKey();
#endif //wxUSE_UNICODE
// Looking at method wxKeyEvent::GetX
long retwxKeyEventGetX0 = mywxKeyEvent->GetX();
// Looking at method wxKeyEvent::GetY
long retwxKeyEventGetY0 = mywxKeyEvent->GetY();
// Looking at method wxKeyEvent::HasModifiers
bool retwxKeyEventHasModifiers0 = mywxKeyEvent->HasModifiers();
// Looking at method wxKeyEvent::MetaDown
bool retwxKeyEventMetaDown0 = mywxKeyEvent->MetaDown();
// Looking at method wxKeyEvent::ShiftDown
bool retwxKeyEventShiftDown0 = mywxKeyEvent->ShiftDown();

// Looking at class wxLayoutAlgorithm
wxLayoutAlgorithm * mywxLayoutAlgorithm;
// Looking at method wxLayoutAlgorithm::wxLayoutAlgorithm
wxLayoutAlgorithm * newwxLayoutAlgorithm0 = new wxLayoutAlgorithm();
// Looking at method wxLayoutAlgorithm::LayoutFrame
wxFrame*  * wxLayoutAlgorithmLayoutFrameframe0;
wxWindow*  * wxLayoutAlgorithmLayoutFramemainWindow1;
bool retwxLayoutAlgorithmLayoutFrame0 = mywxLayoutAlgorithm->LayoutFrame( * wxLayoutAlgorithmLayoutFrameframe0,  * wxLayoutAlgorithmLayoutFramemainWindow1);
// Looking at method wxLayoutAlgorithm::LayoutMDIFrame
wxMDIParentFrame*  * wxLayoutAlgorithmLayoutMDIFrameframe0;
wxRect*  * wxLayoutAlgorithmLayoutMDIFramerect1;
bool retwxLayoutAlgorithmLayoutMDIFrame0 = mywxLayoutAlgorithm->LayoutMDIFrame( * wxLayoutAlgorithmLayoutMDIFrameframe0,  * wxLayoutAlgorithmLayoutMDIFramerect1);
// Looking at method wxLayoutAlgorithm::LayoutWindow
wxWindow*  * wxLayoutAlgorithmLayoutWindowparent0;
wxWindow*  * wxLayoutAlgorithmLayoutWindowmainWindow1;
bool retwxLayoutAlgorithmLayoutWindow0 = mywxLayoutAlgorithm->LayoutWindow( * wxLayoutAlgorithmLayoutWindowparent0,  * wxLayoutAlgorithmLayoutWindowmainWindow1);

// Looking at class wxLayoutConstraints
wxLayoutConstraints * mywxLayoutConstraints;
// Looking at method wxLayoutConstraints::wxLayoutConstraints
wxLayoutConstraints * newwxLayoutConstraints0 = new wxLayoutConstraints();
// Looking at method wxLayoutConstraints::bottom
// Looking at method wxLayoutConstraints::centreX
// Looking at method wxLayoutConstraints::centreY
// Looking at method wxLayoutConstraints::height
// Looking at method wxLayoutConstraints::left
// Looking at method wxLayoutConstraints::right
// Looking at method wxLayoutConstraints::top
// Looking at method wxLayoutConstraints::width

// Looking at class wxListBox
wxListBox * mywxListBox;
// Looking at method wxListBox::wxListBox
wxListBox * newwxListBox0 = new wxListBox();
wxWindow*  * wxListBoxwxListBoxparent0;
wxWindowID  * wxListBoxwxListBoxid1;
wxPoint  * wxListBoxwxListBoxpos2;
wxSize  * wxListBoxwxListBoxsize3;
int  * wxListBoxwxListBoxn4;
wxString  * * wxListBoxwxListBoxchoicesptr5;
long  * wxListBoxwxListBoxstyle6;
wxValidator  * wxListBoxwxListBoxvalidator7;
wxString  * wxListBoxwxListBoxname8;
wxListBox * newwxListBox1 = new wxListBox( * wxListBoxwxListBoxparent0,  * wxListBoxwxListBoxid1,  * wxListBoxwxListBoxpos2,  * wxListBoxwxListBoxsize3,  * wxListBoxwxListBoxn4,  * wxListBoxwxListBoxchoicesptr5,  * wxListBoxwxListBoxstyle6,  * wxListBoxwxListBoxvalidator7,  * wxListBoxwxListBoxname8);
wxWindow*  * wxListBoxwxListBoxparent9;
wxWindowID  * wxListBoxwxListBoxid10;
wxPoint  * wxListBoxwxListBoxpos11;
wxSize  * wxListBoxwxListBoxsize12;
wxArrayString  * wxListBoxwxListBoxchoices13;
long  * wxListBoxwxListBoxstyle14;
wxValidator  * wxListBoxwxListBoxvalidator15;
wxString  * wxListBoxwxListBoxname16;
wxListBox * newwxListBox2 = new wxListBox( * wxListBoxwxListBoxparent9,  * wxListBoxwxListBoxid10,  * wxListBoxwxListBoxpos11,  * wxListBoxwxListBoxsize12,  * wxListBoxwxListBoxchoices13,  * wxListBoxwxListBoxstyle14,  * wxListBoxwxListBoxvalidator15,  * wxListBoxwxListBoxname16);
// Looking at method wxListBox::Create
wxWindow*  * wxListBoxCreateparent0;
wxWindowID  * wxListBoxCreateid1;
wxPoint  * wxListBoxCreatepos2;
wxSize  * wxListBoxCreatesize3;
int  * wxListBoxCreaten4;
wxString  * * wxListBoxCreatechoicesptr5;
long  * wxListBoxCreatestyle6;
wxValidator  * wxListBoxCreatevalidator7;
wxString  * wxListBoxCreatename8;
bool retwxListBoxCreate0 = mywxListBox->Create( * wxListBoxCreateparent0,  * wxListBoxCreateid1,  * wxListBoxCreatepos2,  * wxListBoxCreatesize3,  * wxListBoxCreaten4,  * wxListBoxCreatechoicesptr5,  * wxListBoxCreatestyle6,  * wxListBoxCreatevalidator7,  * wxListBoxCreatename8);
wxWindow*  * wxListBoxCreateparent9;
wxWindowID  * wxListBoxCreateid10;
wxPoint  * wxListBoxCreatepos11;
wxSize  * wxListBoxCreatesize12;
wxArrayString  * wxListBoxCreatechoices13;
long  * wxListBoxCreatestyle14;
wxValidator  * wxListBoxCreatevalidator15;
wxString  * wxListBoxCreatename16;
bool retwxListBoxCreate1 = mywxListBox->Create( * wxListBoxCreateparent9,  * wxListBoxCreateid10,  * wxListBoxCreatepos11,  * wxListBoxCreatesize12,  * wxListBoxCreatechoices13,  * wxListBoxCreatestyle14,  * wxListBoxCreatevalidator15,  * wxListBoxCreatename16);
// Looking at method wxListBox::Deselect
int  * wxListBoxDeselectn0;
mywxListBox->Deselect( * wxListBoxDeselectn0);
// Looking at method wxListBox::GetSelections
wxArrayInt  * wxListBoxGetSelectionsselections0;
int retwxListBoxGetSelections0 = mywxListBox->GetSelections( * wxListBoxGetSelectionsselections0);
// Looking at method wxListBox::InsertItems
int  * wxListBoxInsertItemsnItems0;
wxString * * wxListBoxInsertItemsitems1;
int  * wxListBoxInsertItemspos2;
mywxListBox->InsertItems( * wxListBoxInsertItemsnItems0,  * wxListBoxInsertItemsitems1,  * wxListBoxInsertItemspos2);
wxArrayString  * wxListBoxInsertItemsnItems3;
int  * wxListBoxInsertItemspos4;
mywxListBox->InsertItems( * wxListBoxInsertItemsnItems3,  * wxListBoxInsertItemspos4);
// Looking at method wxListBox::IsSelected
int  * wxListBoxIsSelectedn0;
bool retwxListBoxIsSelected0 = mywxListBox->IsSelected( * wxListBoxIsSelectedn0);
// Looking at method wxListBox::Set
int  * wxListBoxSetn0;
wxString*  * wxListBoxSetchoices1;
void ** * wxListBoxSetclientData2;
mywxListBox->Set( * wxListBoxSetn0,  * wxListBoxSetchoices1,  * wxListBoxSetclientData2);
wxArrayString  * wxListBoxSetchoices3;
void ** * wxListBoxSetclientData4;
mywxListBox->Set( * wxListBoxSetchoices3,  * wxListBoxSetclientData4);
// Looking at method wxListBox::SetFirstItem
int  * wxListBoxSetFirstItemn0;
mywxListBox->SetFirstItem( * wxListBoxSetFirstItemn0);
wxString  * wxListBoxSetFirstItemstring1;
mywxListBox->SetFirstItem( * wxListBoxSetFirstItemstring1);

// Looking at class wxListCtrl
wxListCtrl * mywxListCtrl;
// Looking at method wxListCtrl::wxListCtrl
wxListCtrl * newwxListCtrl0 = new wxListCtrl();
wxWindow*  * wxListCtrlwxListCtrlparent0;
wxWindowID  * wxListCtrlwxListCtrlid1;
wxPoint  * wxListCtrlwxListCtrlpos2;
wxSize  * wxListCtrlwxListCtrlsize3;
long  * wxListCtrlwxListCtrlstyle4;
wxValidator  * wxListCtrlwxListCtrlvalidator5;
wxString  * wxListCtrlwxListCtrlname6;
wxListCtrl * newwxListCtrl1 = new wxListCtrl( * wxListCtrlwxListCtrlparent0,  * wxListCtrlwxListCtrlid1,  * wxListCtrlwxListCtrlpos2,  * wxListCtrlwxListCtrlsize3,  * wxListCtrlwxListCtrlstyle4,  * wxListCtrlwxListCtrlvalidator5,  * wxListCtrlwxListCtrlname6);
// Looking at method wxListCtrl::Arrange
int  * wxListCtrlArrangeflag0;
bool retwxListCtrlArrange0 = mywxListCtrl->Arrange( * wxListCtrlArrangeflag0);
// Looking at method wxListCtrl::AssignImageList
wxImageList*  * wxListCtrlAssignImageListimageList0;
int  * wxListCtrlAssignImageListwhich1;
mywxListCtrl->AssignImageList( * wxListCtrlAssignImageListimageList0,  * wxListCtrlAssignImageListwhich1);
// Looking at method wxListCtrl::ClearAll
mywxListCtrl->ClearAll();
// Looking at method wxListCtrl::Create
wxWindow*  * wxListCtrlCreateparent0;
wxWindowID  * wxListCtrlCreateid1;
wxPoint  * wxListCtrlCreatepos2;
wxSize  * wxListCtrlCreatesize3;
long  * wxListCtrlCreatestyle4;
wxValidator  * wxListCtrlCreatevalidator5;
wxString  * wxListCtrlCreatename6;
bool retwxListCtrlCreate0 = mywxListCtrl->Create( * wxListCtrlCreateparent0,  * wxListCtrlCreateid1,  * wxListCtrlCreatepos2,  * wxListCtrlCreatesize3,  * wxListCtrlCreatestyle4,  * wxListCtrlCreatevalidator5,  * wxListCtrlCreatename6);
// Looking at method wxListCtrl::DeleteAllItems
bool retwxListCtrlDeleteAllItems0 = mywxListCtrl->DeleteAllItems();
// Looking at method wxListCtrl::DeleteColumn
int  * wxListCtrlDeleteColumncol0;
bool retwxListCtrlDeleteColumn0 = mywxListCtrl->DeleteColumn( * wxListCtrlDeleteColumncol0);
// Looking at method wxListCtrl::DeleteItem
long  * wxListCtrlDeleteItemitem0;
bool retwxListCtrlDeleteItem0 = mywxListCtrl->DeleteItem( * wxListCtrlDeleteItemitem0);
// Looking at method wxListCtrl::EditLabel
long  * wxListCtrlEditLabelitem0;
mywxListCtrl->EditLabel( * wxListCtrlEditLabelitem0);
// Looking at method wxListCtrl::EnsureVisible
long  * wxListCtrlEnsureVisibleitem0;
bool retwxListCtrlEnsureVisible0 = mywxListCtrl->EnsureVisible( * wxListCtrlEnsureVisibleitem0);
// Looking at method wxListCtrl::FindItem
long  * wxListCtrlFindItemstart0;
wxString  * wxListCtrlFindItemstr1;
bool  * wxListCtrlFindItempartial2;
long retwxListCtrlFindItem0 = mywxListCtrl->FindItem( * wxListCtrlFindItemstart0,  * wxListCtrlFindItemstr1,  * wxListCtrlFindItempartial2);
long  * wxListCtrlFindItemstart3;
long  * wxListCtrlFindItemdata4;
long retwxListCtrlFindItem1 = mywxListCtrl->FindItem( * wxListCtrlFindItemstart3,  * wxListCtrlFindItemdata4);
long  * wxListCtrlFindItemstart5;
wxPoint  * wxListCtrlFindItempt6;
int  * wxListCtrlFindItemdirection7;
long retwxListCtrlFindItem2 = mywxListCtrl->FindItem( * wxListCtrlFindItemstart5,  * wxListCtrlFindItempt6,  * wxListCtrlFindItemdirection7);
// Looking at method wxListCtrl::GetColumn
int  * wxListCtrlGetColumncol0;
wxListItem  * wxListCtrlGetColumnitem1;
bool retwxListCtrlGetColumn0 = mywxListCtrl->GetColumn( * wxListCtrlGetColumncol0,  * wxListCtrlGetColumnitem1);
// Looking at method wxListCtrl::GetColumnCount
int retwxListCtrlGetColumnCount0 = mywxListCtrl->GetColumnCount();
// Looking at method wxListCtrl::GetColumnWidth
int  * wxListCtrlGetColumnWidthcol0;
int retwxListCtrlGetColumnWidth0 = mywxListCtrl->GetColumnWidth( * wxListCtrlGetColumnWidthcol0);
// Looking at method wxListCtrl::GetCountPerPage
int retwxListCtrlGetCountPerPage0 = mywxListCtrl->GetCountPerPage();
// Looking at method wxListCtrl::GetImageList
int  * wxListCtrlGetImageListwhich0;
wxImageList* retwxListCtrlGetImageList0 = mywxListCtrl->GetImageList( * wxListCtrlGetImageListwhich0);
// Looking at method wxListCtrl::GetItem
wxListItem  * wxListCtrlGetIteminfo0;
bool retwxListCtrlGetItem0 = mywxListCtrl->GetItem( * wxListCtrlGetIteminfo0);
// Looking at method wxListCtrl::GetItemBackgroundColour
long  * wxListCtrlGetItemBackgroundColouritem0;
wxColour retwxListCtrlGetItemBackgroundColour0 = mywxListCtrl->GetItemBackgroundColour( * wxListCtrlGetItemBackgroundColouritem0);
// Looking at method wxListCtrl::GetItemCount
int retwxListCtrlGetItemCount0 = mywxListCtrl->GetItemCount();
// Looking at method wxListCtrl::GetItemData
long  * wxListCtrlGetItemDataitem0;
long retwxListCtrlGetItemData0 = mywxListCtrl->GetItemData( * wxListCtrlGetItemDataitem0);
// Looking at method wxListCtrl::GetItemPosition
long  * wxListCtrlGetItemPositionitem0;
wxPoint  * wxListCtrlGetItemPositionpos1;
bool retwxListCtrlGetItemPosition0 = mywxListCtrl->GetItemPosition( * wxListCtrlGetItemPositionitem0,  * wxListCtrlGetItemPositionpos1);
// Looking at method wxListCtrl::GetItemRect
long  * wxListCtrlGetItemRectitem0;
wxRect  * wxListCtrlGetItemRectrect1;
int  * wxListCtrlGetItemRectcode2;
bool retwxListCtrlGetItemRect0 = mywxListCtrl->GetItemRect( * wxListCtrlGetItemRectitem0,  * wxListCtrlGetItemRectrect1,  * wxListCtrlGetItemRectcode2);
// Looking at method wxListCtrl::GetItemSpacing
wxSize retwxListCtrlGetItemSpacing0 = mywxListCtrl->GetItemSpacing();
// Looking at method wxListCtrl::GetItemState
long  * wxListCtrlGetItemStateitem0;
long  * wxListCtrlGetItemStatestateMask1;
int retwxListCtrlGetItemState0 = mywxListCtrl->GetItemState( * wxListCtrlGetItemStateitem0,  * wxListCtrlGetItemStatestateMask1);
// Looking at method wxListCtrl::GetItemText
long  * wxListCtrlGetItemTextitem0;
wxString retwxListCtrlGetItemText0 = mywxListCtrl->GetItemText( * wxListCtrlGetItemTextitem0);
// Looking at method wxListCtrl::GetItemTextColour
long  * wxListCtrlGetItemTextColouritem0;
wxColour retwxListCtrlGetItemTextColour0 = mywxListCtrl->GetItemTextColour( * wxListCtrlGetItemTextColouritem0);
// Looking at method wxListCtrl::GetNextItem
long  * wxListCtrlGetNextItemitem0;
int  * wxListCtrlGetNextItemgeometry1;
int  * wxListCtrlGetNextItemstate2;
long retwxListCtrlGetNextItem0 = mywxListCtrl->GetNextItem( * wxListCtrlGetNextItemitem0,  * wxListCtrlGetNextItemgeometry1,  * wxListCtrlGetNextItemstate2);
// Looking at method wxListCtrl::GetSelectedItemCount
int retwxListCtrlGetSelectedItemCount0 = mywxListCtrl->GetSelectedItemCount();
// Looking at method wxListCtrl::GetTextColour
wxColour retwxListCtrlGetTextColour0 = mywxListCtrl->GetTextColour();
// Looking at method wxListCtrl::GetTopItem
long retwxListCtrlGetTopItem0 = mywxListCtrl->GetTopItem();
// Looking at method wxListCtrl::GetViewRect
wxRect retwxListCtrlGetViewRect0 = mywxListCtrl->GetViewRect();
// Looking at method wxListCtrl::HitTest
wxPoint  * wxListCtrlHitTestpoint0;
int  * wxListCtrlHitTestflags1;
long retwxListCtrlHitTest0 = mywxListCtrl->HitTest( * wxListCtrlHitTestpoint0,  * wxListCtrlHitTestflags1);
// Looking at method wxListCtrl::InsertColumn
long  * wxListCtrlInsertColumncol0;
wxListItem  * wxListCtrlInsertColumninfo1;
long retwxListCtrlInsertColumn0 = mywxListCtrl->InsertColumn( * wxListCtrlInsertColumncol0,  * wxListCtrlInsertColumninfo1);
long  * wxListCtrlInsertColumncol2;
wxString  * wxListCtrlInsertColumnheading3;
int  * wxListCtrlInsertColumnformat4;
int  * wxListCtrlInsertColumnwidth5;
long retwxListCtrlInsertColumn1 = mywxListCtrl->InsertColumn( * wxListCtrlInsertColumncol2,  * wxListCtrlInsertColumnheading3,  * wxListCtrlInsertColumnformat4,  * wxListCtrlInsertColumnwidth5);
// Looking at method wxListCtrl::InsertItem
wxListItem  * wxListCtrlInsertIteminfo0;
long retwxListCtrlInsertItem0 = mywxListCtrl->InsertItem( * wxListCtrlInsertIteminfo0);
long  * wxListCtrlInsertItemindex1;
wxString  * wxListCtrlInsertItemlabel2;
long retwxListCtrlInsertItem1 = mywxListCtrl->InsertItem( * wxListCtrlInsertItemindex1,  * wxListCtrlInsertItemlabel2);
long  * wxListCtrlInsertItemindex3;
int  * wxListCtrlInsertItemimageIndex4;
long retwxListCtrlInsertItem2 = mywxListCtrl->InsertItem( * wxListCtrlInsertItemindex3,  * wxListCtrlInsertItemimageIndex4);
long  * wxListCtrlInsertItemindex5;
wxString  * wxListCtrlInsertItemlabel6;
int  * wxListCtrlInsertItemimageIndex7;
long retwxListCtrlInsertItem3 = mywxListCtrl->InsertItem( * wxListCtrlInsertItemindex5,  * wxListCtrlInsertItemlabel6,  * wxListCtrlInsertItemimageIndex7);
// Looking at method wxListCtrl::OnGetItemAttr
// Looking at method wxListCtrl::OnGetItemImage
// Looking at method wxListCtrl::OnGetItemText
// Looking at method wxListCtrl::RefreshItem
long  * wxListCtrlRefreshItemitem0;
mywxListCtrl->RefreshItem( * wxListCtrlRefreshItemitem0);
// Looking at method wxListCtrl::RefreshItems
long  * wxListCtrlRefreshItemsitemFrom0;
long  * wxListCtrlRefreshItemsitemTo1;
mywxListCtrl->RefreshItems( * wxListCtrlRefreshItemsitemFrom0,  * wxListCtrlRefreshItemsitemTo1);
// Looking at method wxListCtrl::ScrollList
int  * wxListCtrlScrollListdx0;
int  * wxListCtrlScrollListdy1;
bool retwxListCtrlScrollList0 = mywxListCtrl->ScrollList( * wxListCtrlScrollListdx0,  * wxListCtrlScrollListdy1);
// Looking at method wxListCtrl::SetBackgroundColour
wxColour  * wxListCtrlSetBackgroundColourcol0;
mywxListCtrl->SetBackgroundColour( * wxListCtrlSetBackgroundColourcol0);
// Looking at method wxListCtrl::SetColumn
int  * wxListCtrlSetColumncol0;
wxListItem  * wxListCtrlSetColumnitem1;
bool retwxListCtrlSetColumn0 = mywxListCtrl->SetColumn( * wxListCtrlSetColumncol0,  * wxListCtrlSetColumnitem1);
// Looking at method wxListCtrl::SetColumnWidth
int  * wxListCtrlSetColumnWidthcol0;
int  * wxListCtrlSetColumnWidthwidth1;
bool retwxListCtrlSetColumnWidth0 = mywxListCtrl->SetColumnWidth( * wxListCtrlSetColumnWidthcol0,  * wxListCtrlSetColumnWidthwidth1);
// Looking at method wxListCtrl::SetImageList
wxImageList*  * wxListCtrlSetImageListimageList0;
int  * wxListCtrlSetImageListwhich1;
mywxListCtrl->SetImageList( * wxListCtrlSetImageListimageList0,  * wxListCtrlSetImageListwhich1);
// Looking at method wxListCtrl::SetItem
wxListItem  * wxListCtrlSetIteminfo0;
bool retwxListCtrlSetItem0 = mywxListCtrl->SetItem( * wxListCtrlSetIteminfo0);
long  * wxListCtrlSetItemindex1;
int  * wxListCtrlSetItemcol2;
wxString * wxListCtrlSetItemlabel3;
int  * wxListCtrlSetItemimageId4;
long retwxListCtrlSetItem1 = mywxListCtrl->SetItem( * wxListCtrlSetItemindex1,  * wxListCtrlSetItemcol2,  * wxListCtrlSetItemlabel3,  * wxListCtrlSetItemimageId4);
long  * wxListCtrlSetItemindex5;
int  * wxListCtrlSetItemcol6;
wxString  * wxListCtrlSetItemlabel7;
int  * wxListCtrlSetItemimageId8;
long retwxListCtrlSetItem2 = mywxListCtrl->SetItem( * wxListCtrlSetItemindex5,  * wxListCtrlSetItemcol6,  * wxListCtrlSetItemlabel7,  * wxListCtrlSetItemimageId8);
// Looking at method wxListCtrl::SetItemBackgroundColour
long  * wxListCtrlSetItemBackgroundColouritem0;
wxColour  * wxListCtrlSetItemBackgroundColourcol1;
mywxListCtrl->SetItemBackgroundColour( * wxListCtrlSetItemBackgroundColouritem0,  * wxListCtrlSetItemBackgroundColourcol1);
// Looking at method wxListCtrl::SetItemCount
long  * wxListCtrlSetItemCountcount0;
mywxListCtrl->SetItemCount( * wxListCtrlSetItemCountcount0);
// Looking at method wxListCtrl::SetItemData
long  * wxListCtrlSetItemDataitem0;
long  * wxListCtrlSetItemDatadata1;
bool retwxListCtrlSetItemData0 = mywxListCtrl->SetItemData( * wxListCtrlSetItemDataitem0,  * wxListCtrlSetItemDatadata1);
// Looking at method wxListCtrl::SetItemImage
long  * wxListCtrlSetItemImageitem0;
int  * wxListCtrlSetItemImageimage1;
bool retwxListCtrlSetItemImage0 = mywxListCtrl->SetItemImage( * wxListCtrlSetItemImageitem0,  * wxListCtrlSetItemImageimage1);
long  * wxListCtrlSetItemImageitem2;
int  * wxListCtrlSetItemImageimage3;
int  * wxListCtrlSetItemImageselImage4;
bool retwxListCtrlSetItemImage1 = mywxListCtrl->SetItemImage( * wxListCtrlSetItemImageitem2,  * wxListCtrlSetItemImageimage3,  * wxListCtrlSetItemImageselImage4);
// Looking at method wxListCtrl::SetItemPosition
long  * wxListCtrlSetItemPositionitem0;
wxPoint  * wxListCtrlSetItemPositionpos1;
bool retwxListCtrlSetItemPosition0 = mywxListCtrl->SetItemPosition( * wxListCtrlSetItemPositionitem0,  * wxListCtrlSetItemPositionpos1);
// Looking at method wxListCtrl::SetItemState
long  * wxListCtrlSetItemStateitem0;
long  * wxListCtrlSetItemStatestate1;
long  * wxListCtrlSetItemStatestateMask2;
bool retwxListCtrlSetItemState0 = mywxListCtrl->SetItemState( * wxListCtrlSetItemStateitem0,  * wxListCtrlSetItemStatestate1,  * wxListCtrlSetItemStatestateMask2);
// Looking at method wxListCtrl::SetItemText
long  * wxListCtrlSetItemTextitem0;
wxString  * wxListCtrlSetItemTexttext1;
mywxListCtrl->SetItemText( * wxListCtrlSetItemTextitem0,  * wxListCtrlSetItemTexttext1);
// Looking at method wxListCtrl::SetItemTextColour
long  * wxListCtrlSetItemTextColouritem0;
wxColour  * wxListCtrlSetItemTextColourcol1;
mywxListCtrl->SetItemTextColour( * wxListCtrlSetItemTextColouritem0,  * wxListCtrlSetItemTextColourcol1);
// Looking at method wxListCtrl::SetSingleStyle
long  * wxListCtrlSetSingleStylestyle0;
bool  * wxListCtrlSetSingleStyleadd1;
mywxListCtrl->SetSingleStyle( * wxListCtrlSetSingleStylestyle0,  * wxListCtrlSetSingleStyleadd1);
// Looking at method wxListCtrl::SetTextColour
wxColour  * wxListCtrlSetTextColourcol0;
mywxListCtrl->SetTextColour( * wxListCtrlSetTextColourcol0);
// Looking at method wxListCtrl::SetWindowStyleFlag
long  * wxListCtrlSetWindowStyleFlagstyle0;
mywxListCtrl->SetWindowStyleFlag( * wxListCtrlSetWindowStyleFlagstyle0);
// Looking at method wxListCtrl::SortItems
wxListCtrlCompare  * wxListCtrlSortItemsfnSortCallBack0;
long  * wxListCtrlSortItemsdata1;
bool retwxListCtrlSortItems0 = mywxListCtrl->SortItems( * wxListCtrlSortItemsfnSortCallBack0,  * wxListCtrlSortItemsdata1);

// Looking at class wxListEvent
wxListEvent * mywxListEvent;
// Looking at method wxListEvent::wxListEvent
WXTYPE  * wxListEventwxListEventcommandType0;
int  * wxListEventwxListEventid1;
wxListEvent * newwxListEvent0 = new wxListEvent( * wxListEventwxListEventcommandType0,  * wxListEventwxListEventid1);
// Looking at method wxListEvent::GetCacheFrom
long retwxListEventGetCacheFrom0 = mywxListEvent->GetCacheFrom();
// Looking at method wxListEvent::GetCacheTo
long retwxListEventGetCacheTo0 = mywxListEvent->GetCacheTo();
// Looking at method wxListEvent::GetKeyCode
int retwxListEventGetKeyCode0 = mywxListEvent->GetKeyCode();
// Looking at method wxListEvent::GetIndex
long retwxListEventGetIndex0 = mywxListEvent->GetIndex();
// Looking at method wxListEvent::GetColumn
int retwxListEventGetColumn0 = mywxListEvent->GetColumn();
// Looking at method wxListEvent::GetPoint
wxPoint retwxListEventGetPoint0 = mywxListEvent->GetPoint();
// Looking at method wxListEvent::GetLabel
const wxString retwxListEventGetLabel0 = mywxListEvent->GetLabel();
// Looking at method wxListEvent::GetText
const wxString retwxListEventGetText0 = mywxListEvent->GetText();
// Looking at method wxListEvent::GetImage
int retwxListEventGetImage0 = mywxListEvent->GetImage();
// Looking at method wxListEvent::GetData
long retwxListEventGetData0 = mywxListEvent->GetData();
// Looking at method wxListEvent::GetMask
long retwxListEventGetMask0 = mywxListEvent->GetMask();
// Looking at method wxListEvent::GetItem
const wxListItem retwxListEventGetItem0 = mywxListEvent->GetItem();
// Looking at method wxListEvent::IsEditCancelled
bool retwxListEventIsEditCancelled0 = mywxListEvent->IsEditCancelled();

// Looking at class wxListItem
wxListItem * mywxListItem;
// Looking at method wxListItem::wxListItem
wxListItem * newwxListItem0 = new wxListItem();
// Looking at method wxListItem::Clear
mywxListItem->Clear();
// Looking at method wxListItem::GetAlign
wxListColumnFormat retwxListItemGetAlign0 = mywxListItem->GetAlign();
// Looking at method wxListItem::GetBackgroundColour
wxColour retwxListItemGetBackgroundColour0 = mywxListItem->GetBackgroundColour();
// Looking at method wxListItem::GetColumn
int retwxListItemGetColumn0 = mywxListItem->GetColumn();
// Looking at method wxListItem::GetData
long retwxListItemGetData0 = mywxListItem->GetData();
// Looking at method wxListItem::GetFont
wxFont retwxListItemGetFont0 = mywxListItem->GetFont();
// Looking at method wxListItem::GetId
long retwxListItemGetId0 = mywxListItem->GetId();
// Looking at method wxListItem::GetImage
int retwxListItemGetImage0 = mywxListItem->GetImage();
// Looking at method wxListItem::GetMask
long retwxListItemGetMask0 = mywxListItem->GetMask();
// Looking at method wxListItem::GetState
long retwxListItemGetState0 = mywxListItem->GetState();
// Looking at method wxListItem::GetText
const wxString retwxListItemGetText0 = mywxListItem->GetText();
// Looking at method wxListItem::GetTextColour
wxColour retwxListItemGetTextColour0 = mywxListItem->GetTextColour();
// Looking at method wxListItem::GetWidth
int retwxListItemGetWidth0 = mywxListItem->GetWidth();
// Looking at method wxListItem::SetAlign
wxListColumnFormat  * wxListItemSetAlignalign0;
mywxListItem->SetAlign( * wxListItemSetAlignalign0);
// Looking at method wxListItem::SetBackgroundColour
wxColour  * wxListItemSetBackgroundColourcolBack0;
mywxListItem->SetBackgroundColour( * wxListItemSetBackgroundColourcolBack0);
// Looking at method wxListItem::SetColumn
int  * wxListItemSetColumncol0;
mywxListItem->SetColumn( * wxListItemSetColumncol0);
// Looking at method wxListItem::SetData
long  * wxListItemSetDatadata0;
mywxListItem->SetData( * wxListItemSetDatadata0);
void*  * wxListItemSetDatadata1;
mywxListItem->SetData( * wxListItemSetDatadata1);
// Looking at method wxListItem::SetFont
wxFont  * wxListItemSetFontfont0;
mywxListItem->SetFont( * wxListItemSetFontfont0);
// Looking at method wxListItem::SetId
long  * wxListItemSetIdid0;
mywxListItem->SetId( * wxListItemSetIdid0);
// Looking at method wxListItem::SetImage
int  * wxListItemSetImageimage0;
mywxListItem->SetImage( * wxListItemSetImageimage0);
// Looking at method wxListItem::SetMask
long  * wxListItemSetMaskmask0;
mywxListItem->SetMask( * wxListItemSetMaskmask0);
// Looking at method wxListItem::SetState
long  * wxListItemSetStatestate0;
mywxListItem->SetState( * wxListItemSetStatestate0);
// Looking at method wxListItem::SetStateMask
long  * wxListItemSetStateMaskstateMask0;
mywxListItem->SetStateMask( * wxListItemSetStateMaskstateMask0);
// Looking at method wxListItem::SetText
wxString  * wxListItemSetTexttext0;
mywxListItem->SetText( * wxListItemSetTexttext0);
// Looking at method wxListItem::SetTextColour
wxColour  * wxListItemSetTextColourcolText0;
mywxListItem->SetTextColour( * wxListItemSetTextColourcolText0);
// Looking at method wxListItem::SetWidth
int  * wxListItemSetWidthwidth0;
mywxListItem->SetWidth( * wxListItemSetWidthwidth0);

// Looking at class wxListView
wxListView * mywxListView;
// Looking at method wxListView::ClearColumnImage
int  * wxListViewClearColumnImagecol0;
mywxListView->ClearColumnImage( * wxListViewClearColumnImagecol0);
// Looking at method wxListView::Focus
long  * wxListViewFocusindex0;
mywxListView->Focus( * wxListViewFocusindex0);
// Looking at method wxListView::GetFirstSelected
long retwxListViewGetFirstSelected0 = mywxListView->GetFirstSelected();
// Looking at method wxListView::GetFocusedItem
long retwxListViewGetFocusedItem0 = mywxListView->GetFocusedItem();
// Looking at method wxListView::GetNextSelected
long  * wxListViewGetNextSelecteditem0;
long retwxListViewGetNextSelected0 = mywxListView->GetNextSelected( * wxListViewGetNextSelecteditem0);
// Looking at method wxListView::IsSelected
long  * wxListViewIsSelectedindex0;
bool retwxListViewIsSelected0 = mywxListView->IsSelected( * wxListViewIsSelectedindex0);
// Looking at method wxListView::Select
bool  * wxListViewSelecton0;
mywxListView->Select( * wxListViewSelecton0);
// Looking at method wxListView::SetColumnImage
int  * wxListViewSetColumnImagecol0;
int  * wxListViewSetColumnImageimage1;
mywxListView->SetColumnImage( * wxListViewSetColumnImagecol0,  * wxListViewSetColumnImageimage1);

// Looking at class wxListbook
wxListbook * mywxListbook;

// Looking at class wxLocale
wxLocale * mywxLocale;
// Looking at method wxLocale::
// Looking at method wxLocale::wxLocale
wxLocale * newwxLocale0 = new wxLocale();
int  * wxLocalewxLocalelanguage0;
int  * wxLocalewxLocaleflags1;
wxLocale * newwxLocale1 = new wxLocale( * wxLocalewxLocalelanguage0,  * wxLocalewxLocaleflags1);
char * * wxLocalewxLocaleszName2;
char * * wxLocalewxLocaleszShort3;
char * * wxLocalewxLocaleszLocale4;
bool  * wxLocalewxLocalebLoadDefault5;
bool  * wxLocalewxLocalebConvertEncoding6;
wxLocale * newwxLocale2 = new wxLocale( * wxLocalewxLocaleszName2,  * wxLocalewxLocaleszShort3,  * wxLocalewxLocaleszLocale4,  * wxLocalewxLocalebLoadDefault5,  * wxLocalewxLocalebConvertEncoding6);
// Looking at method wxLocale::AddCatalog
char * * wxLocaleAddCatalogszDomain0;
bool retwxLocaleAddCatalog0 = mywxLocale->AddCatalog( * wxLocaleAddCatalogszDomain0);
char * * wxLocaleAddCatalogszDomain1;
wxLanguage * wxLocaleAddCatalogmsgIdLanguage2;
char * * wxLocaleAddCatalogmsgIdCharset3;
bool retwxLocaleAddCatalog1 = mywxLocale->AddCatalog( * wxLocaleAddCatalogszDomain1,  * wxLocaleAddCatalogmsgIdLanguage2,  * wxLocaleAddCatalogmsgIdCharset3);
// Looking at method wxLocale::AddCatalogLookupPathPrefix
wxString  * wxLocaleAddCatalogLookupPathPrefixprefix0;
mywxLocale->AddCatalogLookupPathPrefix( * wxLocaleAddCatalogLookupPathPrefixprefix0);
// Looking at method wxLocale::AddLanguage
wxLanguageInfo  * wxLocaleAddLanguageinfo0;
mywxLocale->AddLanguage( * wxLocaleAddLanguageinfo0);
// Looking at method wxLocale::FindLanguageInfo
wxString  * wxLocaleFindLanguageInfolocale0;
static wxLanguageInfo * retwxLocaleFindLanguageInfo0 = mywxLocale->FindLanguageInfo( * wxLocaleFindLanguageInfolocale0);
// Looking at method wxLocale::GetCanonicalName
wxString retwxLocaleGetCanonicalName0 = mywxLocale->GetCanonicalName();
// Looking at method wxLocale::GetLanguage
int retwxLocaleGetLanguage0 = mywxLocale->GetLanguage();
// Looking at method wxLocale::GetLanguageInfo
int  * wxLocaleGetLanguageInfolang0;
static wxLanguageInfo * retwxLocaleGetLanguageInfo0 = mywxLocale->GetLanguageInfo( * wxLocaleGetLanguageInfolang0);
// Looking at method wxLocale::GetLanguageName
int  * wxLocaleGetLanguageNamelang0;
static wxString retwxLocaleGetLanguageName0 = mywxLocale->GetLanguageName( * wxLocaleGetLanguageNamelang0);
// Looking at method wxLocale::GetLocale
const char* retwxLocaleGetLocale0 = mywxLocale->GetLocale();
// Looking at method wxLocale::GetName
const wxString retwxLocaleGetName0 = mywxLocale->GetName();
// Looking at method wxLocale::GetString
char * * wxLocaleGetStringszOrigString0;
char * * wxLocaleGetStringszDomain1;
const char* retwxLocaleGetString0 = mywxLocale->GetString( * wxLocaleGetStringszOrigString0,  * wxLocaleGetStringszDomain1);
char * * wxLocaleGetStringszOrigString2;
char * * wxLocaleGetStringszOrigString23;
size_t  * wxLocaleGetStringn4;
char * * wxLocaleGetStringszDomain5;
const char* retwxLocaleGetString1 = mywxLocale->GetString( * wxLocaleGetStringszOrigString2,  * wxLocaleGetStringszOrigString23,  * wxLocaleGetStringn4,  * wxLocaleGetStringszDomain5);
// Looking at method wxLocale::GetHeaderValue
char * * wxLocaleGetHeaderValueszHeader0;
char * * wxLocaleGetHeaderValueszDomain1;
wxString retwxLocaleGetHeaderValue0 = mywxLocale->GetHeaderValue( * wxLocaleGetHeaderValueszHeader0,  * wxLocaleGetHeaderValueszDomain1);
// Looking at method wxLocale::GetSysName
wxString retwxLocaleGetSysName0 = mywxLocale->GetSysName();
// Looking at method wxLocale::GetSystemEncoding
static wxFontEncoding retwxLocaleGetSystemEncoding0 = mywxLocale->GetSystemEncoding();
// Looking at method wxLocale::GetSystemEncodingName
static wxString retwxLocaleGetSystemEncodingName0 = mywxLocale->GetSystemEncodingName();
// Looking at method wxLocale::GetSystemLanguage
static int retwxLocaleGetSystemLanguage0 = mywxLocale->GetSystemLanguage();
// Looking at method wxLocale::Init
int  * wxLocaleInitlanguage0;
int  * wxLocaleInitflags1;
bool retwxLocaleInit0 = mywxLocale->Init( * wxLocaleInitlanguage0,  * wxLocaleInitflags1);
char * * wxLocaleInitszName2;
char * * wxLocaleInitszShort3;
char * * wxLocaleInitszLocale4;
bool  * wxLocaleInitbLoadDefault5;
bool  * wxLocaleInitbConvertEncoding6;
bool retwxLocaleInit1 = mywxLocale->Init( * wxLocaleInitszName2,  * wxLocaleInitszShort3,  * wxLocaleInitszLocale4,  * wxLocaleInitbLoadDefault5,  * wxLocaleInitbConvertEncoding6);
// Looking at method wxLocale::IsLoaded
char*  * wxLocaleIsLoadeddomain0;
bool retwxLocaleIsLoaded0 = mywxLocale->IsLoaded( * wxLocaleIsLoadeddomain0);
// Looking at method wxLocale::IsOk
bool retwxLocaleIsOk0 = mywxLocale->IsOk();

// Looking at class wxLongLong
wxLongLong * mywxLongLong;
// Looking at method wxLongLong::wxLongLong
wxLongLong * newwxLongLong0 = new wxLongLong();
wxLongLong_t  * wxLongLongwxLongLongll0;
wxLongLong * newwxLongLong1 = new wxLongLong( * wxLongLongwxLongLongll0);
long  * wxLongLongwxLongLonghi1;
unsigned long  * wxLongLongwxLongLonglo2;
wxLongLong * newwxLongLong2 = new wxLongLong( * wxLongLongwxLongLonghi1,  * wxLongLongwxLongLonglo2);
// Looking at method wxLongLong::Abs
wxLongLong retwxLongLongAbs0 = mywxLongLong->Abs();
wxLongLong retwxLongLongAbs1 = mywxLongLong->Abs();
// Looking at method wxLongLong::Assign
double  * wxLongLongAssignd0;
wxLongLong retwxLongLongAssign0 = mywxLongLong->Assign( * wxLongLongAssignd0);
// Looking at method wxLongLong::GetHi
long retwxLongLongGetHi0 = mywxLongLong->GetHi();
// Looking at method wxLongLong::GetLo
unsigned long retwxLongLongGetLo0 = mywxLongLong->GetLo();
// Looking at method wxLongLong::GetValue
wxLongLong_t retwxLongLongGetValue0 = mywxLongLong->GetValue();
// Looking at method wxLongLong::ToLong
long retwxLongLongToLong0 = mywxLongLong->ToLong();
// Looking at method wxLongLong::ToString
wxString retwxLongLongToString0 = mywxLongLong->ToString();
#if wxMBFILES == 1

// Looking at class wxMBConvFile
wxMBConvFile * mywxMBConvFile;
// Looking at method wxMBConvFile::MB2WC
wchar_t*  * wxMBConvFileMB2WCbuf0;
char*  * wxMBConvFileMB2WCpsz1;
size_t  * wxMBConvFileMB2WCn2;
size_t retwxMBConvFileMB2WC0 = mywxMBConvFile->MB2WC( * wxMBConvFileMB2WCbuf0,  * wxMBConvFileMB2WCpsz1,  * wxMBConvFileMB2WCn2);
// Looking at method wxMBConvFile::WC2MB
char*  * wxMBConvFileWC2MBbuf0;
wchar_t*  * wxMBConvFileWC2MBpsz1;
size_t  * wxMBConvFileWC2MBn2;
size_t retwxMBConvFileWC2MB0 = mywxMBConvFile->WC2MB( * wxMBConvFileWC2MBbuf0,  * wxMBConvFileWC2MBpsz1,  * wxMBConvFileWC2MBn2);
#endif //wxMBFILES

// Looking at class wxMBConvUTF16
wxMBConvUTF16 * mywxMBConvUTF16;
// Looking at method wxMBConvUTF16::MB2WC
wchar_t*  * wxMBConvUTF16MB2WCbuf0;
char*  * wxMBConvUTF16MB2WCpsz1;
size_t  * wxMBConvUTF16MB2WCn2;
size_t retwxMBConvUTF16MB2WC0 = mywxMBConvUTF16->MB2WC( * wxMBConvUTF16MB2WCbuf0,  * wxMBConvUTF16MB2WCpsz1,  * wxMBConvUTF16MB2WCn2);
// Looking at method wxMBConvUTF16::WC2MB
char*  * wxMBConvUTF16WC2MBbuf0;
wchar_t*  * wxMBConvUTF16WC2MBpsz1;
size_t  * wxMBConvUTF16WC2MBn2;
size_t retwxMBConvUTF16WC2MB0 = mywxMBConvUTF16->WC2MB( * wxMBConvUTF16WC2MBbuf0,  * wxMBConvUTF16WC2MBpsz1,  * wxMBConvUTF16WC2MBn2);

// Looking at class wxMBConvUTF32
wxMBConvUTF32 * mywxMBConvUTF32;
// Looking at method wxMBConvUTF32::MB2WC
wchar_t*  * wxMBConvUTF32MB2WCbuf0;
char*  * wxMBConvUTF32MB2WCpsz1;
size_t  * wxMBConvUTF32MB2WCn2;
size_t retwxMBConvUTF32MB2WC0 = mywxMBConvUTF32->MB2WC( * wxMBConvUTF32MB2WCbuf0,  * wxMBConvUTF32MB2WCpsz1,  * wxMBConvUTF32MB2WCn2);
// Looking at method wxMBConvUTF32::WC2MB
char*  * wxMBConvUTF32WC2MBbuf0;
wchar_t*  * wxMBConvUTF32WC2MBpsz1;
size_t  * wxMBConvUTF32WC2MBn2;
size_t retwxMBConvUTF32WC2MB0 = mywxMBConvUTF32->WC2MB( * wxMBConvUTF32WC2MBbuf0,  * wxMBConvUTF32WC2MBpsz1,  * wxMBConvUTF32WC2MBn2);

// Looking at class wxMBConvUTF7
wxMBConvUTF7 * mywxMBConvUTF7;
// Looking at method wxMBConvUTF7::MB2WC
wchar_t*  * wxMBConvUTF7MB2WCbuf0;
char*  * wxMBConvUTF7MB2WCpsz1;
size_t  * wxMBConvUTF7MB2WCn2;
size_t retwxMBConvUTF7MB2WC0 = mywxMBConvUTF7->MB2WC( * wxMBConvUTF7MB2WCbuf0,  * wxMBConvUTF7MB2WCpsz1,  * wxMBConvUTF7MB2WCn2);
// Looking at method wxMBConvUTF7::WC2MB
char*  * wxMBConvUTF7WC2MBbuf0;
wchar_t*  * wxMBConvUTF7WC2MBpsz1;
size_t  * wxMBConvUTF7WC2MBn2;
size_t retwxMBConvUTF7WC2MB0 = mywxMBConvUTF7->WC2MB( * wxMBConvUTF7WC2MBbuf0,  * wxMBConvUTF7WC2MBpsz1,  * wxMBConvUTF7WC2MBn2);

// Looking at class wxMBConvUTF8
wxMBConvUTF8 * mywxMBConvUTF8;
// Looking at method wxMBConvUTF8::MB2WC
wchar_t*  * wxMBConvUTF8MB2WCbuf0;
char*  * wxMBConvUTF8MB2WCpsz1;
size_t  * wxMBConvUTF8MB2WCn2;
size_t retwxMBConvUTF8MB2WC0 = mywxMBConvUTF8->MB2WC( * wxMBConvUTF8MB2WCbuf0,  * wxMBConvUTF8MB2WCpsz1,  * wxMBConvUTF8MB2WCn2);
// Looking at method wxMBConvUTF8::WC2MB
char*  * wxMBConvUTF8WC2MBbuf0;
wchar_t*  * wxMBConvUTF8WC2MBpsz1;
size_t  * wxMBConvUTF8WC2MBn2;
size_t retwxMBConvUTF8WC2MB0 = mywxMBConvUTF8->WC2MB( * wxMBConvUTF8WC2MBbuf0,  * wxMBConvUTF8WC2MBpsz1,  * wxMBConvUTF8WC2MBn2);

// Looking at class wxMDIChildFrame
wxMDIChildFrame * mywxMDIChildFrame;
// Looking at method wxMDIChildFrame::wxMDIChildFrame
wxMDIChildFrame * newwxMDIChildFrame0 = new wxMDIChildFrame();
wxMDIParentFrame*  * wxMDIChildFramewxMDIChildFrameparent0;
wxWindowID  * wxMDIChildFramewxMDIChildFrameid1;
wxString  * wxMDIChildFramewxMDIChildFrametitle2;
wxPoint  * wxMDIChildFramewxMDIChildFramepos3;
wxSize  * wxMDIChildFramewxMDIChildFramesize4;
long  * wxMDIChildFramewxMDIChildFramestyle5;
wxString  * wxMDIChildFramewxMDIChildFramename6;
wxMDIChildFrame * newwxMDIChildFrame1 = new wxMDIChildFrame( * wxMDIChildFramewxMDIChildFrameparent0,  * wxMDIChildFramewxMDIChildFrameid1,  * wxMDIChildFramewxMDIChildFrametitle2,  * wxMDIChildFramewxMDIChildFramepos3,  * wxMDIChildFramewxMDIChildFramesize4,  * wxMDIChildFramewxMDIChildFramestyle5,  * wxMDIChildFramewxMDIChildFramename6);
// Looking at method wxMDIChildFrame::Activate
mywxMDIChildFrame->Activate();
// Looking at method wxMDIChildFrame::Create
wxWindow*  * wxMDIChildFrameCreateparent0;
wxWindowID  * wxMDIChildFrameCreateid1;
wxString  * wxMDIChildFrameCreatetitle2;
wxPoint  * wxMDIChildFrameCreatepos3;
wxSize  * wxMDIChildFrameCreatesize4;
long  * wxMDIChildFrameCreatestyle5;
wxString  * wxMDIChildFrameCreatename6;
bool retwxMDIChildFrameCreate0 = mywxMDIChildFrame->Create( * wxMDIChildFrameCreateparent0,  * wxMDIChildFrameCreateid1,  * wxMDIChildFrameCreatetitle2,  * wxMDIChildFrameCreatepos3,  * wxMDIChildFrameCreatesize4,  * wxMDIChildFrameCreatestyle5,  * wxMDIChildFrameCreatename6);
// Looking at method wxMDIChildFrame::Maximize
bool * wxMDIChildFrameMaximizemaximize0;
mywxMDIChildFrame->Maximize( * wxMDIChildFrameMaximizemaximize0);
// Looking at method wxMDIChildFrame::Restore
mywxMDIChildFrame->Restore();

// Looking at class wxMDIClientWindow
wxMDIClientWindow * mywxMDIClientWindow;
// Looking at method wxMDIClientWindow::wxMDIClientWindow
wxMDIClientWindow * newwxMDIClientWindow0 = new wxMDIClientWindow();
wxMDIParentFrame*  * wxMDIClientWindowwxMDIClientWindowparent0;
long  * wxMDIClientWindowwxMDIClientWindowstyle1;
wxMDIClientWindow * newwxMDIClientWindow1 = new wxMDIClientWindow( * wxMDIClientWindowwxMDIClientWindowparent0,  * wxMDIClientWindowwxMDIClientWindowstyle1);
// Looking at method wxMDIClientWindow::CreateClient
wxMDIParentFrame*  * wxMDIClientWindowCreateClientparent0;
long  * wxMDIClientWindowCreateClientstyle1;
bool retwxMDIClientWindowCreateClient0 = mywxMDIClientWindow->CreateClient( * wxMDIClientWindowCreateClientparent0,  * wxMDIClientWindowCreateClientstyle1);

// Looking at class wxMDIParentFrame
wxMDIParentFrame * mywxMDIParentFrame;
// Looking at method wxMDIParentFrame::wxMDIParentFrame
wxMDIParentFrame * newwxMDIParentFrame0 = new wxMDIParentFrame();
wxWindow*  * wxMDIParentFramewxMDIParentFrameparent0;
wxWindowID  * wxMDIParentFramewxMDIParentFrameid1;
wxString  * wxMDIParentFramewxMDIParentFrametitle2;
wxPoint  * wxMDIParentFramewxMDIParentFramepos3;
wxSize  * wxMDIParentFramewxMDIParentFramesize4;
long  * wxMDIParentFramewxMDIParentFramestyle5;
wxString  * wxMDIParentFramewxMDIParentFramename6;
wxMDIParentFrame * newwxMDIParentFrame1 = new wxMDIParentFrame( * wxMDIParentFramewxMDIParentFrameparent0,  * wxMDIParentFramewxMDIParentFrameid1,  * wxMDIParentFramewxMDIParentFrametitle2,  * wxMDIParentFramewxMDIParentFramepos3,  * wxMDIParentFramewxMDIParentFramesize4,  * wxMDIParentFramewxMDIParentFramestyle5,  * wxMDIParentFramewxMDIParentFramename6);
// Looking at method wxMDIParentFrame::ActivateNext
mywxMDIParentFrame->ActivateNext();
// Looking at method wxMDIParentFrame::ActivatePrevious
mywxMDIParentFrame->ActivatePrevious();
// Looking at method wxMDIParentFrame::ArrangeIcons
mywxMDIParentFrame->ArrangeIcons();
// Looking at method wxMDIParentFrame::Cascade
mywxMDIParentFrame->Cascade();
// Looking at method wxMDIParentFrame::Create
wxWindow*  * wxMDIParentFrameCreateparent0;
wxWindowID  * wxMDIParentFrameCreateid1;
wxString  * wxMDIParentFrameCreatetitle2;
wxPoint  * wxMDIParentFrameCreatepos3;
wxSize  * wxMDIParentFrameCreatesize4;
long  * wxMDIParentFrameCreatestyle5;
wxString  * wxMDIParentFrameCreatename6;
bool retwxMDIParentFrameCreate0 = mywxMDIParentFrame->Create( * wxMDIParentFrameCreateparent0,  * wxMDIParentFrameCreateid1,  * wxMDIParentFrameCreatetitle2,  * wxMDIParentFrameCreatepos3,  * wxMDIParentFrameCreatesize4,  * wxMDIParentFrameCreatestyle5,  * wxMDIParentFrameCreatename6);
// Looking at method wxMDIParentFrame::GetClientSize
// Looking at method wxMDIParentFrame::GetActiveChild
wxMDIChildFrame* retwxMDIParentFrameGetActiveChild0 = mywxMDIParentFrame->GetActiveChild();
// Looking at method wxMDIParentFrame::GetClientWindow
wxMDIClientWindow* retwxMDIParentFrameGetClientWindow0 = mywxMDIParentFrame->GetClientWindow();
// Looking at method wxMDIParentFrame::GetToolBar
// Looking at method wxMDIParentFrame::OnCreateClient
// Looking at method wxMDIParentFrame::SetToolBar
// Looking at method wxMDIParentFrame::Tile
mywxMDIParentFrame->Tile();

// Looking at class wxMask
wxMask * mywxMask;
// Looking at method wxMask::wxMask
wxMask * newwxMask0 = new wxMask();
wxBitmap  * wxMaskwxMaskbitmap0;
wxMask * newwxMask1 = new wxMask( * wxMaskwxMaskbitmap0);
wxBitmap  * wxMaskwxMaskbitmap1;
wxColour  * wxMaskwxMaskcolour2;
wxMask * newwxMask2 = new wxMask( * wxMaskwxMaskbitmap1,  * wxMaskwxMaskcolour2);
wxBitmap  * wxMaskwxMaskbitmap3;
int  * wxMaskwxMaskindex4;
wxMask * newwxMask3 = new wxMask( * wxMaskwxMaskbitmap3,  * wxMaskwxMaskindex4);
// Looking at method wxMask::Create
wxBitmap  * wxMaskCreatebitmap0;
bool retwxMaskCreate0 = mywxMask->Create( * wxMaskCreatebitmap0);
wxBitmap  * wxMaskCreatebitmap1;
wxColour  * wxMaskCreatecolour2;
bool retwxMaskCreate1 = mywxMask->Create( * wxMaskCreatebitmap1,  * wxMaskCreatecolour2);
wxBitmap  * wxMaskCreatebitmap3;
int  * wxMaskCreateindex4;
bool retwxMaskCreate2 = mywxMask->Create( * wxMaskCreatebitmap3,  * wxMaskCreateindex4);

// Looking at class wxMaximizeEvent
wxMaximizeEvent * mywxMaximizeEvent;
// Looking at method wxMaximizeEvent::wxMaximizeEvent
int  * wxMaximizeEventwxMaximizeEventid0;
wxMaximizeEvent * newwxMaximizeEvent0 = new wxMaximizeEvent( * wxMaximizeEventwxMaximizeEventid0);

// Looking at class wxMemoryBuffer
wxMemoryBuffer * mywxMemoryBuffer;
// Looking at method wxMemoryBuffer::wxMemoryBuffer
wxMemoryBuffer  * wxMemoryBufferwxMemoryBuffersrc0;
wxMemoryBuffer * newwxMemoryBuffer0 = new wxMemoryBuffer( * wxMemoryBufferwxMemoryBuffersrc0);
size_t  * wxMemoryBufferwxMemoryBuffersize1;
wxMemoryBuffer * newwxMemoryBuffer1 = new wxMemoryBuffer( * wxMemoryBufferwxMemoryBuffersize1);
// Looking at method wxMemoryBuffer::GetData
mywxMemoryBuffer->GetData();
// Looking at method wxMemoryBuffer::GetBufSize
size_t retwxMemoryBufferGetBufSize0 = mywxMemoryBuffer->GetBufSize();
// Looking at method wxMemoryBuffer::GetDataLen
size_t retwxMemoryBufferGetDataLen0 = mywxMemoryBuffer->GetDataLen();
// Looking at method wxMemoryBuffer::SetBufSize
size_t  * wxMemoryBufferSetBufSizesize0;
mywxMemoryBuffer->SetBufSize( * wxMemoryBufferSetBufSizesize0);
// Looking at method wxMemoryBuffer::SetDataLen
size_t  * wxMemoryBufferSetDataLensize0;
mywxMemoryBuffer->SetDataLen( * wxMemoryBufferSetDataLensize0);
// Looking at method wxMemoryBuffer::GetWriteBuf
size_t  * wxMemoryBufferGetWriteBufsizeNeeded0;
mywxMemoryBuffer->GetWriteBuf( * wxMemoryBufferGetWriteBufsizeNeeded0);
// Looking at method wxMemoryBuffer::UngetWriteBuf
size_t  * wxMemoryBufferUngetWriteBufsizeUsed0;
mywxMemoryBuffer->UngetWriteBuf( * wxMemoryBufferUngetWriteBufsizeUsed0);
// Looking at method wxMemoryBuffer::GetAppendBuf
size_t  * wxMemoryBufferGetAppendBufsizeNeeded0;
mywxMemoryBuffer->GetAppendBuf( * wxMemoryBufferGetAppendBufsizeNeeded0);
// Looking at method wxMemoryBuffer::UngetAppendBuf
size_t  * wxMemoryBufferUngetAppendBufsizeUsed0;
mywxMemoryBuffer->UngetAppendBuf( * wxMemoryBufferUngetAppendBufsizeUsed0);
// Looking at method wxMemoryBuffer::AppendByte
char  * wxMemoryBufferAppendBytedata0;
mywxMemoryBuffer->AppendByte( * wxMemoryBufferAppendBytedata0);
// Looking at method wxMemoryBuffer::AppendData
void*  * wxMemoryBufferAppendDatadata0;
size_t  * wxMemoryBufferAppendDatalen1;
mywxMemoryBuffer->AppendData( * wxMemoryBufferAppendDatadata0,  * wxMemoryBufferAppendDatalen1);

// Looking at class wxMemoryDC
wxMemoryDC * mywxMemoryDC;
// Looking at method wxMemoryDC::wxMemoryDC
wxMemoryDC * newwxMemoryDC0 = new wxMemoryDC();
// Looking at method wxMemoryDC::SelectObject
wxBitmap  * wxMemoryDCSelectObjectbitmap0;
mywxMemoryDC->SelectObject( * wxMemoryDCSelectObjectbitmap0);

// Looking at class wxMemoryFSHandler
wxMemoryFSHandler * mywxMemoryFSHandler;
// Looking at method wxMemoryFSHandler::wxMemoryFSHandler
wxMemoryFSHandler * newwxMemoryFSHandler0 = new wxMemoryFSHandler();
// Looking at method wxMemoryFSHandler::AddFile
wxString  * wxMemoryFSHandlerAddFilefilename0;
wxImage  * wxMemoryFSHandlerAddFileimage1;
long  * wxMemoryFSHandlerAddFiletype2;
mywxMemoryFSHandler->AddFile( * wxMemoryFSHandlerAddFilefilename0,  * wxMemoryFSHandlerAddFileimage1,  * wxMemoryFSHandlerAddFiletype2);
wxString  * wxMemoryFSHandlerAddFilefilename3;
wxBitmap  * wxMemoryFSHandlerAddFilebitmap4;
long  * wxMemoryFSHandlerAddFiletype5;
mywxMemoryFSHandler->AddFile( * wxMemoryFSHandlerAddFilefilename3,  * wxMemoryFSHandlerAddFilebitmap4,  * wxMemoryFSHandlerAddFiletype5);
wxString  * wxMemoryFSHandlerAddFilefilename6;
wxString  * wxMemoryFSHandlerAddFiletextdata7;
mywxMemoryFSHandler->AddFile( * wxMemoryFSHandlerAddFilefilename6,  * wxMemoryFSHandlerAddFiletextdata7);
wxString  * wxMemoryFSHandlerAddFilefilename8;
void*  * wxMemoryFSHandlerAddFilebinarydata9;
size_t  * wxMemoryFSHandlerAddFilesize10;
mywxMemoryFSHandler->AddFile( * wxMemoryFSHandlerAddFilefilename8,  * wxMemoryFSHandlerAddFilebinarydata9,  * wxMemoryFSHandlerAddFilesize10);
// Looking at method wxMemoryFSHandler::RemoveFile
wxString  * wxMemoryFSHandlerRemoveFilefilename0;
mywxMemoryFSHandler->RemoveFile( * wxMemoryFSHandlerRemoveFilefilename0);

// Looking at class wxMemoryInputStream
wxMemoryInputStream * mywxMemoryInputStream;
// Looking at method wxMemoryInputStream::wxMemoryInputStream
char *  * wxMemoryInputStreamwxMemoryInputStreamdata0;
size_t  * wxMemoryInputStreamwxMemoryInputStreamlen1;
wxMemoryInputStream * newwxMemoryInputStream0 = new wxMemoryInputStream( * wxMemoryInputStreamwxMemoryInputStreamdata0,  * wxMemoryInputStreamwxMemoryInputStreamlen1);

// Looking at class wxMemoryOutputStream
wxMemoryOutputStream * mywxMemoryOutputStream;
// Looking at method wxMemoryOutputStream::wxMemoryOutputStream
char *  * wxMemoryOutputStreamwxMemoryOutputStreamdata0;
size_t  * wxMemoryOutputStreamwxMemoryOutputStreamlength1;
wxMemoryOutputStream * newwxMemoryOutputStream0 = new wxMemoryOutputStream( * wxMemoryOutputStreamwxMemoryOutputStreamdata0,  * wxMemoryOutputStreamwxMemoryOutputStreamlength1);
// Looking at method wxMemoryOutputStream::CopyTo
char * * wxMemoryOutputStreamCopyTobuffer0;
size_t  * wxMemoryOutputStreamCopyTolen1;
size_t retwxMemoryOutputStreamCopyTo0 = mywxMemoryOutputStream->CopyTo( * wxMemoryOutputStreamCopyTobuffer0,  * wxMemoryOutputStreamCopyTolen1);

// Looking at class wxMenu
wxMenu * mywxMenu;
// Looking at method wxMenu::wxMenu
wxString  * wxMenuwxMenutitle0;
long  * wxMenuwxMenustyle1;
wxMenu * newwxMenu0 = new wxMenu( * wxMenuwxMenutitle0,  * wxMenuwxMenustyle1);
long  * wxMenuwxMenustyle2;
wxMenu * newwxMenu1 = new wxMenu( * wxMenuwxMenustyle2);
// Looking at method wxMenu::Append
int  * wxMenuAppendid0;
wxString   * wxMenuAppenditem1;
wxString  * wxMenuAppendhelpString2;
wxItemKind  * wxMenuAppendkind3;
wxMenuItem* retwxMenuAppend0 = mywxMenu->Append( * wxMenuAppendid0,  * wxMenuAppenditem1,  * wxMenuAppendhelpString2,  * wxMenuAppendkind3);
int  * wxMenuAppendid4;
wxString   * wxMenuAppenditem5;
wxMenu * * wxMenuAppendsubMenu6;
wxString  * wxMenuAppendhelpString7;
wxMenuItem* retwxMenuAppend1 = mywxMenu->Append( * wxMenuAppendid4,  * wxMenuAppenditem5,  * wxMenuAppendsubMenu6,  * wxMenuAppendhelpString7);
wxMenuItem*  * wxMenuAppendmenuItem8;
wxMenuItem* retwxMenuAppend2 = mywxMenu->Append( * wxMenuAppendmenuItem8);
// Looking at method wxMenu::AppendCheckItem
int  * wxMenuAppendCheckItemid0;
wxString   * wxMenuAppendCheckItemitem1;
wxString  * wxMenuAppendCheckItemhelpString2;
wxMenuItem* retwxMenuAppendCheckItem0 = mywxMenu->AppendCheckItem( * wxMenuAppendCheckItemid0,  * wxMenuAppendCheckItemitem1,  * wxMenuAppendCheckItemhelpString2);
// Looking at method wxMenu::AppendRadioItem
int  * wxMenuAppendRadioItemid0;
wxString   * wxMenuAppendRadioItemitem1;
wxString  * wxMenuAppendRadioItemhelpString2;
wxMenuItem* retwxMenuAppendRadioItem0 = mywxMenu->AppendRadioItem( * wxMenuAppendRadioItemid0,  * wxMenuAppendRadioItemitem1,  * wxMenuAppendRadioItemhelpString2);
// Looking at method wxMenu::AppendSeparator
wxMenuItem* retwxMenuAppendSeparator0 = mywxMenu->AppendSeparator();
// Looking at method wxMenu::Break
mywxMenu->Break();
// Looking at method wxMenu::Check
int  * wxMenuCheckid0;
bool  * wxMenuCheckcheck1;
mywxMenu->Check( * wxMenuCheckid0,  * wxMenuCheckcheck1);
// Looking at method wxMenu::Delete
int  * wxMenuDeleteid0;
mywxMenu->Delete( * wxMenuDeleteid0);
wxMenuItem * * wxMenuDeleteitem1;
mywxMenu->Delete( * wxMenuDeleteitem1);
// Looking at method wxMenu::Destroy
int  * wxMenuDestroyid0;
mywxMenu->Destroy( * wxMenuDestroyid0);
wxMenuItem * * wxMenuDestroyitem1;
mywxMenu->Destroy( * wxMenuDestroyitem1);
// Looking at method wxMenu::Enable
int  * wxMenuEnableid0;
bool  * wxMenuEnableenable1;
mywxMenu->Enable( * wxMenuEnableid0,  * wxMenuEnableenable1);
// Looking at method wxMenu::FindItem
wxString  * wxMenuFindItemitemString0;
int retwxMenuFindItem0 = mywxMenu->FindItem( * wxMenuFindItemitemString0);
int  * wxMenuFindItemid1;
wxMenu ** * wxMenuFindItemmenu2;
wxMenuItem * retwxMenuFindItem1 = mywxMenu->FindItem( * wxMenuFindItemid1,  * wxMenuFindItemmenu2);
// Looking at method wxMenu::FindItemByPosition
size_t  * wxMenuFindItemByPositionposition0;
wxMenuItem* retwxMenuFindItemByPosition0 = mywxMenu->FindItemByPosition( * wxMenuFindItemByPositionposition0);
// Looking at method wxMenu::GetHelpString
int  * wxMenuGetHelpStringid0;
wxString retwxMenuGetHelpString0 = mywxMenu->GetHelpString( * wxMenuGetHelpStringid0);
// Looking at method wxMenu::GetLabel
int  * wxMenuGetLabelid0;
wxString retwxMenuGetLabel0 = mywxMenu->GetLabel( * wxMenuGetLabelid0);
// Looking at method wxMenu::GetMenuItemCount
size_t retwxMenuGetMenuItemCount0 = mywxMenu->GetMenuItemCount();
// Looking at method wxMenu::GetMenuItems
wxMenuItemList retwxMenuGetMenuItems0 = mywxMenu->GetMenuItems();
// Looking at method wxMenu::GetTitle
wxString retwxMenuGetTitle0 = mywxMenu->GetTitle();
// Looking at method wxMenu::Insert
size_t  * wxMenuInsertpos0;
wxMenuItem * * wxMenuInsertitem1;
wxMenuItem* retwxMenuInsert0 = mywxMenu->Insert( * wxMenuInsertpos0,  * wxMenuInsertitem1);
size_t  * wxMenuInsertpos2;
int  * wxMenuInsertid3;
wxString   * wxMenuInsertitem4;
wxString  * wxMenuInserthelpString5;
wxItemKind  * wxMenuInsertkind6;
wxMenuItem* retwxMenuInsert1 = mywxMenu->Insert( * wxMenuInsertpos2,  * wxMenuInsertid3,  * wxMenuInsertitem4,  * wxMenuInserthelpString5,  * wxMenuInsertkind6);
// Looking at method wxMenu::InsertCheckItem
size_t  * wxMenuInsertCheckItempos0;
int  * wxMenuInsertCheckItemid1;
wxString   * wxMenuInsertCheckItemitem2;
wxString  * wxMenuInsertCheckItemhelpString3;
wxMenuItem* retwxMenuInsertCheckItem0 = mywxMenu->InsertCheckItem( * wxMenuInsertCheckItempos0,  * wxMenuInsertCheckItemid1,  * wxMenuInsertCheckItemitem2,  * wxMenuInsertCheckItemhelpString3);
// Looking at method wxMenu::InsertRadioItem
size_t  * wxMenuInsertRadioItempos0;
int  * wxMenuInsertRadioItemid1;
wxString   * wxMenuInsertRadioItemitem2;
wxString  * wxMenuInsertRadioItemhelpString3;
wxMenuItem* retwxMenuInsertRadioItem0 = mywxMenu->InsertRadioItem( * wxMenuInsertRadioItempos0,  * wxMenuInsertRadioItemid1,  * wxMenuInsertRadioItemitem2,  * wxMenuInsertRadioItemhelpString3);
// Looking at method wxMenu::InsertSeparator
size_t  * wxMenuInsertSeparatorpos0;
wxMenuItem* retwxMenuInsertSeparator0 = mywxMenu->InsertSeparator( * wxMenuInsertSeparatorpos0);
// Looking at method wxMenu::IsChecked
int  * wxMenuIsCheckedid0;
bool retwxMenuIsChecked0 = mywxMenu->IsChecked( * wxMenuIsCheckedid0);
// Looking at method wxMenu::IsEnabled
int  * wxMenuIsEnabledid0;
bool retwxMenuIsEnabled0 = mywxMenu->IsEnabled( * wxMenuIsEnabledid0);
// Looking at method wxMenu::Prepend
wxMenuItem * * wxMenuPrependitem0;
wxMenuItem* retwxMenuPrepend0 = mywxMenu->Prepend( * wxMenuPrependitem0);
int  * wxMenuPrependid1;
wxString   * wxMenuPrependitem2;
wxString  * wxMenuPrependhelpString3;
wxItemKind  * wxMenuPrependkind4;
wxMenuItem* retwxMenuPrepend1 = mywxMenu->Prepend( * wxMenuPrependid1,  * wxMenuPrependitem2,  * wxMenuPrependhelpString3,  * wxMenuPrependkind4);
// Looking at method wxMenu::PrependCheckItem
int  * wxMenuPrependCheckItemid0;
wxString   * wxMenuPrependCheckItemitem1;
wxString  * wxMenuPrependCheckItemhelpString2;
wxMenuItem* retwxMenuPrependCheckItem0 = mywxMenu->PrependCheckItem( * wxMenuPrependCheckItemid0,  * wxMenuPrependCheckItemitem1,  * wxMenuPrependCheckItemhelpString2);
// Looking at method wxMenu::PrependRadioItem
int  * wxMenuPrependRadioItemid0;
wxString   * wxMenuPrependRadioItemitem1;
wxString  * wxMenuPrependRadioItemhelpString2;
wxMenuItem* retwxMenuPrependRadioItem0 = mywxMenu->PrependRadioItem( * wxMenuPrependRadioItemid0,  * wxMenuPrependRadioItemitem1,  * wxMenuPrependRadioItemhelpString2);
// Looking at method wxMenu::PrependSeparator
wxMenuItem* retwxMenuPrependSeparator0 = mywxMenu->PrependSeparator();
// Looking at method wxMenu::Remove
int  * wxMenuRemoveid0;
wxMenuItem * retwxMenuRemove0 = mywxMenu->Remove( * wxMenuRemoveid0);
wxMenuItem * * wxMenuRemoveitem1;
wxMenuItem * retwxMenuRemove1 = mywxMenu->Remove( * wxMenuRemoveitem1);
// Looking at method wxMenu::SetHelpString
int  * wxMenuSetHelpStringid0;
wxString  * wxMenuSetHelpStringhelpString1;
mywxMenu->SetHelpString( * wxMenuSetHelpStringid0,  * wxMenuSetHelpStringhelpString1);
// Looking at method wxMenu::SetLabel
int  * wxMenuSetLabelid0;
wxString  * wxMenuSetLabellabel1;
mywxMenu->SetLabel( * wxMenuSetLabelid0,  * wxMenuSetLabellabel1);
// Looking at method wxMenu::SetTitle
wxString  * wxMenuSetTitletitle0;
mywxMenu->SetTitle( * wxMenuSetTitletitle0);
// Looking at method wxMenu::UpdateUI
wxEvtHandler*  * wxMenuUpdateUIsource0;
mywxMenu->UpdateUI( * wxMenuUpdateUIsource0);

// Looking at class wxMenuBar
wxMenuBar * mywxMenuBar;
// Looking at method wxMenuBar::wxMenuBar
long  * wxMenuBarwxMenuBarstyle0;
wxMenuBar * newwxMenuBar0 = new wxMenuBar( * wxMenuBarwxMenuBarstyle0);
int  * wxMenuBarwxMenuBarn1;
wxMenu*  * * wxMenuBarwxMenuBarmenusptr2;
wxString  * * wxMenuBarwxMenuBartitlesptr3;
wxMenuBar * newwxMenuBar1 = new wxMenuBar( * wxMenuBarwxMenuBarn1,  * wxMenuBarwxMenuBarmenusptr2,  * wxMenuBarwxMenuBartitlesptr3);
// Looking at method wxMenuBar::Append
wxMenu * * wxMenuBarAppendmenu0;
wxString  * wxMenuBarAppendtitle1;
bool retwxMenuBarAppend0 = mywxMenuBar->Append( * wxMenuBarAppendmenu0,  * wxMenuBarAppendtitle1);
// Looking at method wxMenuBar::Check
int  * wxMenuBarCheckid0;
bool  * wxMenuBarCheckcheck1;
mywxMenuBar->Check( * wxMenuBarCheckid0,  * wxMenuBarCheckcheck1);
// Looking at method wxMenuBar::Enable
int  * wxMenuBarEnableid0;
bool  * wxMenuBarEnableenable1;
mywxMenuBar->Enable( * wxMenuBarEnableid0,  * wxMenuBarEnableenable1);
// Looking at method wxMenuBar::EnableTop
int  * wxMenuBarEnableToppos0;
bool  * wxMenuBarEnableTopenable1;
mywxMenuBar->EnableTop( * wxMenuBarEnableToppos0,  * wxMenuBarEnableTopenable1);
// Looking at method wxMenuBar::FindMenu
wxString  * wxMenuBarFindMenutitle0;
int retwxMenuBarFindMenu0 = mywxMenuBar->FindMenu( * wxMenuBarFindMenutitle0);
// Looking at method wxMenuBar::FindMenuItem
wxString  * wxMenuBarFindMenuItemmenuString0;
wxString  * wxMenuBarFindMenuItemitemString1;
int retwxMenuBarFindMenuItem0 = mywxMenuBar->FindMenuItem( * wxMenuBarFindMenuItemmenuString0,  * wxMenuBarFindMenuItemitemString1);
// Looking at method wxMenuBar::FindItem
int  * wxMenuBarFindItemid0;
wxMenu ** * wxMenuBarFindItemmenu1;
wxMenuItem * retwxMenuBarFindItem0 = mywxMenuBar->FindItem( * wxMenuBarFindItemid0,  * wxMenuBarFindItemmenu1);
// Looking at method wxMenuBar::GetHelpString
int  * wxMenuBarGetHelpStringid0;
wxString retwxMenuBarGetHelpString0 = mywxMenuBar->GetHelpString( * wxMenuBarGetHelpStringid0);
// Looking at method wxMenuBar::GetLabel
int  * wxMenuBarGetLabelid0;
wxString retwxMenuBarGetLabel0 = mywxMenuBar->GetLabel( * wxMenuBarGetLabelid0);
// Looking at method wxMenuBar::GetLabelTop
int  * wxMenuBarGetLabelToppos0;
wxString retwxMenuBarGetLabelTop0 = mywxMenuBar->GetLabelTop( * wxMenuBarGetLabelToppos0);
// Looking at method wxMenuBar::GetMenu
int  * wxMenuBarGetMenumenuIndex0;
wxMenu* retwxMenuBarGetMenu0 = mywxMenuBar->GetMenu( * wxMenuBarGetMenumenuIndex0);
// Looking at method wxMenuBar::GetMenuCount
int retwxMenuBarGetMenuCount0 = mywxMenuBar->GetMenuCount();
// Looking at method wxMenuBar::Insert
size_t  * wxMenuBarInsertpos0;
wxMenu * * wxMenuBarInsertmenu1;
wxString  * wxMenuBarInserttitle2;
bool retwxMenuBarInsert0 = mywxMenuBar->Insert( * wxMenuBarInsertpos0,  * wxMenuBarInsertmenu1,  * wxMenuBarInserttitle2);
// Looking at method wxMenuBar::IsChecked
int  * wxMenuBarIsCheckedid0;
bool retwxMenuBarIsChecked0 = mywxMenuBar->IsChecked( * wxMenuBarIsCheckedid0);
// Looking at method wxMenuBar::IsEnabled
int  * wxMenuBarIsEnabledid0;
bool retwxMenuBarIsEnabled0 = mywxMenuBar->IsEnabled( * wxMenuBarIsEnabledid0);
// Looking at method wxMenuBar::Refresh
mywxMenuBar->Refresh();
// Looking at method wxMenuBar::Remove
size_t  * wxMenuBarRemovepos0;
wxMenu * retwxMenuBarRemove0 = mywxMenuBar->Remove( * wxMenuBarRemovepos0);
// Looking at method wxMenuBar::Replace
size_t  * wxMenuBarReplacepos0;
wxMenu * * wxMenuBarReplacemenu1;
wxString  * wxMenuBarReplacetitle2;
wxMenu * retwxMenuBarReplace0 = mywxMenuBar->Replace( * wxMenuBarReplacepos0,  * wxMenuBarReplacemenu1,  * wxMenuBarReplacetitle2);
// Looking at method wxMenuBar::SetHelpString
int  * wxMenuBarSetHelpStringid0;
wxString  * wxMenuBarSetHelpStringhelpString1;
mywxMenuBar->SetHelpString( * wxMenuBarSetHelpStringid0,  * wxMenuBarSetHelpStringhelpString1);
// Looking at method wxMenuBar::SetLabel
int  * wxMenuBarSetLabelid0;
wxString  * wxMenuBarSetLabellabel1;
mywxMenuBar->SetLabel( * wxMenuBarSetLabelid0,  * wxMenuBarSetLabellabel1);
// Looking at method wxMenuBar::SetLabelTop
int  * wxMenuBarSetLabelToppos0;
wxString  * wxMenuBarSetLabelToplabel1;
mywxMenuBar->SetLabelTop( * wxMenuBarSetLabelToppos0,  * wxMenuBarSetLabelToplabel1);

// Looking at class wxMenuEvent
wxMenuEvent * mywxMenuEvent;
// Looking at method wxMenuEvent::wxMenuEvent
WXTYPE  * wxMenuEventwxMenuEventid0;
int  * wxMenuEventwxMenuEventid1;
wxMenu*  * wxMenuEventwxMenuEventmenu2;
wxMenuEvent * newwxMenuEvent0 = new wxMenuEvent( * wxMenuEventwxMenuEventid0,  * wxMenuEventwxMenuEventid1,  * wxMenuEventwxMenuEventmenu2);
// Looking at method wxMenuEvent::GetMenu
wxMenu * retwxMenuEventGetMenu0 = mywxMenuEvent->GetMenu();
// Looking at method wxMenuEvent::GetMenuId
int retwxMenuEventGetMenuId0 = mywxMenuEvent->GetMenuId();
// Looking at method wxMenuEvent::IsPopup
bool retwxMenuEventIsPopup0 = mywxMenuEvent->IsPopup();

// Looking at class wxMenuItem
wxMenuItem * mywxMenuItem;
// Looking at method wxMenuItem::wxMenuItem
wxMenu*  * wxMenuItemwxMenuItemparentMenu0;
int  * wxMenuItemwxMenuItemid1;
wxString  * wxMenuItemwxMenuItemtext2;
wxString  * wxMenuItemwxMenuItemhelpString3;
wxItemKind  * wxMenuItemwxMenuItemkind4;
wxMenu*  * wxMenuItemwxMenuItemsubMenu5;
wxMenuItem * newwxMenuItem0 = new wxMenuItem( * wxMenuItemwxMenuItemparentMenu0,  * wxMenuItemwxMenuItemid1,  * wxMenuItemwxMenuItemtext2,  * wxMenuItemwxMenuItemhelpString3,  * wxMenuItemwxMenuItemkind4,  * wxMenuItemwxMenuItemsubMenu5);
// Looking at method wxMenuItem::Check
bool  * wxMenuItemCheckcheck0;
mywxMenuItem->Check( * wxMenuItemCheckcheck0);
// Looking at method wxMenuItem::Enable
bool  * wxMenuItemEnableenable0;
mywxMenuItem->Enable( * wxMenuItemEnableenable0);
// Looking at method wxMenuItem::GetHelp
wxString retwxMenuItemGetHelp0 = mywxMenuItem->GetHelp();
// Looking at method wxMenuItem::GetId
int retwxMenuItemGetId0 = mywxMenuItem->GetId();
// Looking at method wxMenuItem::GetKind
wxItemKind retwxMenuItemGetKind0 = mywxMenuItem->GetKind();
// Looking at method wxMenuItem::GetLabel
wxString retwxMenuItemGetLabel0 = mywxMenuItem->GetLabel();
// Looking at method wxMenuItem::GetLabelFromText
wxString  * wxMenuItemGetLabelFromTexttext0;
static wxString retwxMenuItemGetLabelFromText0 = mywxMenuItem->GetLabelFromText( * wxMenuItemGetLabelFromTexttext0);
// Looking at method wxMenuItem::GetName
wxString retwxMenuItemGetName0 = mywxMenuItem->GetName();
// Looking at method wxMenuItem::GetText
wxString retwxMenuItemGetText0 = mywxMenuItem->GetText();
// Looking at method wxMenuItem::GetSubMenu
wxMenu* retwxMenuItemGetSubMenu0 = mywxMenuItem->GetSubMenu();
// Looking at method wxMenuItem::IsCheckable
bool retwxMenuItemIsCheckable0 = mywxMenuItem->IsCheckable();
// Looking at method wxMenuItem::IsChecked
bool retwxMenuItemIsChecked0 = mywxMenuItem->IsChecked();
// Looking at method wxMenuItem::IsEnabled
bool retwxMenuItemIsEnabled0 = mywxMenuItem->IsEnabled();
// Looking at method wxMenuItem::IsSeparator
bool retwxMenuItemIsSeparator0 = mywxMenuItem->IsSeparator();
// Looking at method wxMenuItem::IsSubMenu
bool retwxMenuItemIsSubMenu0 = mywxMenuItem->IsSubMenu();
// Looking at method wxMenuItem::SetBitmap
wxBitmap  * wxMenuItemSetBitmapbmp0;
mywxMenuItem->SetBitmap( * wxMenuItemSetBitmapbmp0);
// Looking at method wxMenuItem::SetHelp
wxString  * wxMenuItemSetHelphelpString0;
mywxMenuItem->SetHelp( * wxMenuItemSetHelphelpString0);
// Looking at method wxMenuItem::SetText
wxString  * wxMenuItemSetTexttext0;
mywxMenuItem->SetText( * wxMenuItemSetTexttext0);

// Looking at class wxMessageDialog
wxMessageDialog * mywxMessageDialog;
// Looking at method wxMessageDialog::wxMessageDialog
wxWindow*  * wxMessageDialogwxMessageDialogparent0;
wxString  * wxMessageDialogwxMessageDialogmessage1;
wxString  * wxMessageDialogwxMessageDialogcaption2;
long  * wxMessageDialogwxMessageDialogstyle3;
wxPoint  * wxMessageDialogwxMessageDialogpos4;
wxMessageDialog * newwxMessageDialog0 = new wxMessageDialog( * wxMessageDialogwxMessageDialogparent0,  * wxMessageDialogwxMessageDialogmessage1,  * wxMessageDialogwxMessageDialogcaption2,  * wxMessageDialogwxMessageDialogstyle3,  * wxMessageDialogwxMessageDialogpos4);
// Looking at method wxMessageDialog::ShowModal
int retwxMessageDialogShowModal0 = mywxMessageDialog->ShowModal();

// Looking at class wxMimeTypesManager
wxMimeTypesManager * mywxMimeTypesManager;
// Looking at method wxMimeTypesManager::
// Looking at method wxMimeTypesManager::
// Looking at method wxMimeTypesManager::
// Looking at method wxMimeTypesManager::
// Looking at method wxMimeTypesManager::wxMimeTypesManager
wxMimeTypesManager * newwxMimeTypesManager0 = new wxMimeTypesManager();
// Looking at method wxMimeTypesManager::AddFallbacks
wxFileTypeInfo * * wxMimeTypesManagerAddFallbacksfallbacks0;
mywxMimeTypesManager->AddFallbacks( * wxMimeTypesManagerAddFallbacksfallbacks0);
// Looking at method wxMimeTypesManager::GetFileTypeFromExtension
wxString  * wxMimeTypesManagerGetFileTypeFromExtensionextension0;
wxFileType* retwxMimeTypesManagerGetFileTypeFromExtension0 = mywxMimeTypesManager->GetFileTypeFromExtension( * wxMimeTypesManagerGetFileTypeFromExtensionextension0);
// Looking at method wxMimeTypesManager::GetFileTypeFromMimeType
wxString  * wxMimeTypesManagerGetFileTypeFromMimeTypemimeType0;
wxFileType* retwxMimeTypesManagerGetFileTypeFromMimeType0 = mywxMimeTypesManager->GetFileTypeFromMimeType( * wxMimeTypesManagerGetFileTypeFromMimeTypemimeType0);
// Looking at method wxMimeTypesManager::IsOfType
wxString  * wxMimeTypesManagerIsOfTypemimeType0;
wxString  * wxMimeTypesManagerIsOfTypewildcard1;
bool retwxMimeTypesManagerIsOfType0 = mywxMimeTypesManager->IsOfType( * wxMimeTypesManagerIsOfTypemimeType0,  * wxMimeTypesManagerIsOfTypewildcard1);
// Looking at method wxMimeTypesManager::ReadMailcap
wxString  * wxMimeTypesManagerReadMailcapfilename0;
bool  * wxMimeTypesManagerReadMailcapfallback1;
bool retwxMimeTypesManagerReadMailcap0 = mywxMimeTypesManager->ReadMailcap( * wxMimeTypesManagerReadMailcapfilename0,  * wxMimeTypesManagerReadMailcapfallback1);
// Looking at method wxMimeTypesManager::ReadMimeTypes
wxString  * wxMimeTypesManagerReadMimeTypesfilename0;
bool retwxMimeTypesManagerReadMimeTypes0 = mywxMimeTypesManager->ReadMimeTypes( * wxMimeTypesManagerReadMimeTypesfilename0);

// Looking at class wxMiniFrame
wxMiniFrame * mywxMiniFrame;
// Looking at method wxMiniFrame::wxMiniFrame
wxMiniFrame * newwxMiniFrame0 = new wxMiniFrame();
wxWindow*  * wxMiniFramewxMiniFrameparent0;
wxWindowID  * wxMiniFramewxMiniFrameid1;
wxString  * wxMiniFramewxMiniFrametitle2;
wxPoint  * wxMiniFramewxMiniFramepos3;
wxSize  * wxMiniFramewxMiniFramesize4;
long  * wxMiniFramewxMiniFramestyle5;
wxString  * wxMiniFramewxMiniFramename6;
wxMiniFrame * newwxMiniFrame1 = new wxMiniFrame( * wxMiniFramewxMiniFrameparent0,  * wxMiniFramewxMiniFrameid1,  * wxMiniFramewxMiniFrametitle2,  * wxMiniFramewxMiniFramepos3,  * wxMiniFramewxMiniFramesize4,  * wxMiniFramewxMiniFramestyle5,  * wxMiniFramewxMiniFramename6);
// Looking at method wxMiniFrame::Create
wxWindow*  * wxMiniFrameCreateparent0;
wxWindowID  * wxMiniFrameCreateid1;
wxString  * wxMiniFrameCreatetitle2;
wxPoint  * wxMiniFrameCreatepos3;
wxSize  * wxMiniFrameCreatesize4;
long  * wxMiniFrameCreatestyle5;
wxString  * wxMiniFrameCreatename6;
bool retwxMiniFrameCreate0 = mywxMiniFrame->Create( * wxMiniFrameCreateparent0,  * wxMiniFrameCreateid1,  * wxMiniFrameCreatetitle2,  * wxMiniFrameCreatepos3,  * wxMiniFrameCreatesize4,  * wxMiniFrameCreatestyle5,  * wxMiniFrameCreatename6);

// Looking at class wxMirrorDC
wxMirrorDC * mywxMirrorDC;
// Looking at method wxMirrorDC::wxMirrorDC
wxDC  * wxMirrorDCwxMirrorDCdc0;
bool  * wxMirrorDCwxMirrorDCmirror1;
wxMirrorDC * newwxMirrorDC0 = new wxMirrorDC( * wxMirrorDCwxMirrorDCdc0,  * wxMirrorDCwxMirrorDCmirror1);

// Looking at class wxMouseCaptureChangedEvent
wxMouseCaptureChangedEvent * mywxMouseCaptureChangedEvent;
// Looking at method wxMouseCaptureChangedEvent::wxMouseCaptureChangedEvent
wxWindowID  * wxMouseCaptureChangedEventwxMouseCaptureChangedEventwindowId0;
wxWindow*  * wxMouseCaptureChangedEventwxMouseCaptureChangedEventgainedCapture1;
wxMouseCaptureChangedEvent * newwxMouseCaptureChangedEvent0 = new wxMouseCaptureChangedEvent( * wxMouseCaptureChangedEventwxMouseCaptureChangedEventwindowId0,  * wxMouseCaptureChangedEventwxMouseCaptureChangedEventgainedCapture1);
// Looking at method wxMouseCaptureChangedEvent::GetCapturedWindow
wxWindow* retwxMouseCaptureChangedEventGetCapturedWindow0 = mywxMouseCaptureChangedEvent->GetCapturedWindow();

// Looking at class wxMouseEvent
wxMouseEvent * mywxMouseEvent;
// Looking at method wxMouseEvent::m_altDown
// Looking at method wxMouseEvent::m_controlDown
// Looking at method wxMouseEvent::m_leftDown
// Looking at method wxMouseEvent::m_middleDown
// Looking at method wxMouseEvent::m_rightDown
// Looking at method wxMouseEvent::m_metaDown
// Looking at method wxMouseEvent::m_shiftDown
// Looking at method wxMouseEvent::m_x
// Looking at method wxMouseEvent::m_y
// Looking at method wxMouseEvent::m_wheelRotation
// Looking at method wxMouseEvent::m_wheelDelta
// Looking at method wxMouseEvent::m_linesPerAction
// Looking at method wxMouseEvent::wxMouseEvent
WXTYPE  * wxMouseEventwxMouseEventmouseEventType0;
wxMouseEvent * newwxMouseEvent0 = new wxMouseEvent( * wxMouseEventwxMouseEventmouseEventType0);
// Looking at method wxMouseEvent::AltDown
bool retwxMouseEventAltDown0 = mywxMouseEvent->AltDown();
// Looking at method wxMouseEvent::Button
int  * wxMouseEventButtonbutton0;
bool retwxMouseEventButton0 = mywxMouseEvent->Button( * wxMouseEventButtonbutton0);
// Looking at method wxMouseEvent::ButtonDClick
int  * wxMouseEventButtonDClickbut0;
bool retwxMouseEventButtonDClick0 = mywxMouseEvent->ButtonDClick( * wxMouseEventButtonDClickbut0);
// Looking at method wxMouseEvent::ButtonDown
int  * wxMouseEventButtonDownbut0;
bool retwxMouseEventButtonDown0 = mywxMouseEvent->ButtonDown( * wxMouseEventButtonDownbut0);
// Looking at method wxMouseEvent::ButtonUp
int  * wxMouseEventButtonUpbut0;
bool retwxMouseEventButtonUp0 = mywxMouseEvent->ButtonUp( * wxMouseEventButtonUpbut0);
// Looking at method wxMouseEvent::CmdDown
bool retwxMouseEventCmdDown0 = mywxMouseEvent->CmdDown();
// Looking at method wxMouseEvent::ControlDown
bool retwxMouseEventControlDown0 = mywxMouseEvent->ControlDown();
// Looking at method wxMouseEvent::Dragging
bool retwxMouseEventDragging0 = mywxMouseEvent->Dragging();
// Looking at method wxMouseEvent::Entering
bool retwxMouseEventEntering0 = mywxMouseEvent->Entering();
// Looking at method wxMouseEvent::GetButton
int retwxMouseEventGetButton0 = mywxMouseEvent->GetButton();
// Looking at method wxMouseEvent::GetPosition
wxPoint retwxMouseEventGetPosition0 = mywxMouseEvent->GetPosition();
wxCoord*  * wxMouseEventGetPositionx0;
wxCoord*  * wxMouseEventGetPositiony1;
mywxMouseEvent->GetPosition( * wxMouseEventGetPositionx0,  * wxMouseEventGetPositiony1);
long*  * wxMouseEventGetPositionx2;
long*  * wxMouseEventGetPositiony3;
mywxMouseEvent->GetPosition( * wxMouseEventGetPositionx2,  * wxMouseEventGetPositiony3);
// Looking at method wxMouseEvent::GetLogicalPosition
wxDC  * wxMouseEventGetLogicalPositiondc0;
wxPoint retwxMouseEventGetLogicalPosition0 = mywxMouseEvent->GetLogicalPosition( * wxMouseEventGetLogicalPositiondc0);
// Looking at method wxMouseEvent::GetLinesPerAction
int retwxMouseEventGetLinesPerAction0 = mywxMouseEvent->GetLinesPerAction();
// Looking at method wxMouseEvent::GetWheelRotation
int retwxMouseEventGetWheelRotation0 = mywxMouseEvent->GetWheelRotation();
// Looking at method wxMouseEvent::GetWheelDelta
int retwxMouseEventGetWheelDelta0 = mywxMouseEvent->GetWheelDelta();
// Looking at method wxMouseEvent::GetX
long retwxMouseEventGetX0 = mywxMouseEvent->GetX();
// Looking at method wxMouseEvent::GetY
long retwxMouseEventGetY0 = mywxMouseEvent->GetY();
// Looking at method wxMouseEvent::IsButton
bool retwxMouseEventIsButton0 = mywxMouseEvent->IsButton();
// Looking at method wxMouseEvent::IsPageScroll
bool retwxMouseEventIsPageScroll0 = mywxMouseEvent->IsPageScroll();
// Looking at method wxMouseEvent::Leaving
bool retwxMouseEventLeaving0 = mywxMouseEvent->Leaving();
// Looking at method wxMouseEvent::LeftDClick
bool retwxMouseEventLeftDClick0 = mywxMouseEvent->LeftDClick();
// Looking at method wxMouseEvent::LeftDown
bool retwxMouseEventLeftDown0 = mywxMouseEvent->LeftDown();
// Looking at method wxMouseEvent::LeftIsDown
bool retwxMouseEventLeftIsDown0 = mywxMouseEvent->LeftIsDown();
// Looking at method wxMouseEvent::LeftUp
bool retwxMouseEventLeftUp0 = mywxMouseEvent->LeftUp();
// Looking at method wxMouseEvent::MetaDown
bool retwxMouseEventMetaDown0 = mywxMouseEvent->MetaDown();
// Looking at method wxMouseEvent::MiddleDClick
bool retwxMouseEventMiddleDClick0 = mywxMouseEvent->MiddleDClick();
// Looking at method wxMouseEvent::MiddleDown
bool retwxMouseEventMiddleDown0 = mywxMouseEvent->MiddleDown();
// Looking at method wxMouseEvent::MiddleIsDown
bool retwxMouseEventMiddleIsDown0 = mywxMouseEvent->MiddleIsDown();
// Looking at method wxMouseEvent::MiddleUp
bool retwxMouseEventMiddleUp0 = mywxMouseEvent->MiddleUp();
// Looking at method wxMouseEvent::Moving
bool retwxMouseEventMoving0 = mywxMouseEvent->Moving();
// Looking at method wxMouseEvent::RightDClick
bool retwxMouseEventRightDClick0 = mywxMouseEvent->RightDClick();
// Looking at method wxMouseEvent::RightDown
bool retwxMouseEventRightDown0 = mywxMouseEvent->RightDown();
// Looking at method wxMouseEvent::RightIsDown
bool retwxMouseEventRightIsDown0 = mywxMouseEvent->RightIsDown();
// Looking at method wxMouseEvent::RightUp
bool retwxMouseEventRightUp0 = mywxMouseEvent->RightUp();
// Looking at method wxMouseEvent::ShiftDown
bool retwxMouseEventShiftDown0 = mywxMouseEvent->ShiftDown();

// Looking at class wxMoveEvent
wxMoveEvent * mywxMoveEvent;
// Looking at method wxMoveEvent::wxMoveEvent
wxPoint  * wxMoveEventwxMoveEventpt0;
int  * wxMoveEventwxMoveEventid1;
wxMoveEvent * newwxMoveEvent0 = new wxMoveEvent( * wxMoveEventwxMoveEventpt0,  * wxMoveEventwxMoveEventid1);
// Looking at method wxMoveEvent::GetPosition
wxPoint retwxMoveEventGetPosition0 = mywxMoveEvent->GetPosition();

// Looking at class wxMultiChoiceDialog
wxMultiChoiceDialog * mywxMultiChoiceDialog;
// Looking at method wxMultiChoiceDialog::wxMultiChoiceDialog
wxWindow*  * wxMultiChoiceDialogwxMultiChoiceDialogparent0;
wxString  * wxMultiChoiceDialogwxMultiChoiceDialogmessage1;
wxString  * wxMultiChoiceDialogwxMultiChoiceDialogcaption2;
int  * wxMultiChoiceDialogwxMultiChoiceDialogn3;
wxString*  * wxMultiChoiceDialogwxMultiChoiceDialogchoices4;
long  * wxMultiChoiceDialogwxMultiChoiceDialogstyle5;
wxPoint  * wxMultiChoiceDialogwxMultiChoiceDialogpos6;
wxMultiChoiceDialog * newwxMultiChoiceDialog0 = new wxMultiChoiceDialog( * wxMultiChoiceDialogwxMultiChoiceDialogparent0,  * wxMultiChoiceDialogwxMultiChoiceDialogmessage1,  * wxMultiChoiceDialogwxMultiChoiceDialogcaption2,  * wxMultiChoiceDialogwxMultiChoiceDialogn3,  * wxMultiChoiceDialogwxMultiChoiceDialogchoices4,  * wxMultiChoiceDialogwxMultiChoiceDialogstyle5,  * wxMultiChoiceDialogwxMultiChoiceDialogpos6);
wxWindow*  * wxMultiChoiceDialogwxMultiChoiceDialogparent7;
wxString  * wxMultiChoiceDialogwxMultiChoiceDialogmessage8;
wxString  * wxMultiChoiceDialogwxMultiChoiceDialogcaption9;
wxArrayString  * wxMultiChoiceDialogwxMultiChoiceDialogchoices10;
long  * wxMultiChoiceDialogwxMultiChoiceDialogstyle11;
wxPoint  * wxMultiChoiceDialogwxMultiChoiceDialogpos12;
wxMultiChoiceDialog * newwxMultiChoiceDialog1 = new wxMultiChoiceDialog( * wxMultiChoiceDialogwxMultiChoiceDialogparent7,  * wxMultiChoiceDialogwxMultiChoiceDialogmessage8,  * wxMultiChoiceDialogwxMultiChoiceDialogcaption9,  * wxMultiChoiceDialogwxMultiChoiceDialogchoices10,  * wxMultiChoiceDialogwxMultiChoiceDialogstyle11,  * wxMultiChoiceDialogwxMultiChoiceDialogpos12);
// Looking at method wxMultiChoiceDialog::GetSelections
wxArrayInt retwxMultiChoiceDialogGetSelection0 = mywxMultiChoiceDialog->GetSelection();
// Looking at method wxMultiChoiceDialog::SetSelections
wxArrayInt  * wxMultiChoiceDialogSetSelectionsselections0;
mywxMultiChoiceDialog->SetSelections( * wxMultiChoiceDialogSetSelectionsselections0);
// Looking at method wxMultiChoiceDialog::ShowModal
int retwxMultiChoiceDialogShowModal0 = mywxMultiChoiceDialog->ShowModal();

// Looking at class wxMutex
wxMutex * mywxMutex;
// Looking at method wxMutex::wxMutex
wxMutexType  * wxMutexwxMutextype0;
wxMutex * newwxMutex0 = new wxMutex( * wxMutexwxMutextype0);
// Looking at method wxMutex::Lock
wxMutexError retwxMutexLock0 = mywxMutex->Lock();
// Looking at method wxMutex::TryLock
wxMutexError retwxMutexTryLock0 = mywxMutex->TryLock();
// Looking at method wxMutex::Unlock
wxMutexError retwxMutexUnlock0 = mywxMutex->Unlock();

// Looking at class wxMutexLocker
wxMutexLocker * mywxMutexLocker;
// Looking at method wxMutexLocker::wxMutexLocker
wxMutex  * wxMutexLockerwxMutexLockermutex0;
wxMutexLocker * newwxMutexLocker0 = new wxMutexLocker( * wxMutexLockerwxMutexLockermutex0);
// Looking at method wxMutexLocker::IsOk
bool retwxMutexLockerIsOk0 = mywxMutexLocker->IsOk();

// Looking at class wxNotebook
wxNotebook * mywxNotebook;

// Looking at class wxNotebookEvent
wxNotebookEvent * mywxNotebookEvent;
// Looking at method wxNotebookEvent::wxNotebookEvent
wxEventType  * wxNotebookEventwxNotebookEventeventType0;
int  * wxNotebookEventwxNotebookEventid1;
int  * wxNotebookEventwxNotebookEventsel2;
int  * wxNotebookEventwxNotebookEventoldSel3;
wxNotebookEvent * newwxNotebookEvent0 = new wxNotebookEvent( * wxNotebookEventwxNotebookEventeventType0,  * wxNotebookEventwxNotebookEventid1,  * wxNotebookEventwxNotebookEventsel2,  * wxNotebookEventwxNotebookEventoldSel3);
// Looking at method wxNotebookEvent::GetOldSelection
int retwxNotebookEventGetOldSelection0 = mywxNotebookEvent->GetOldSelection();
// Looking at method wxNotebookEvent::GetSelection
int retwxNotebookEventGetSelection0 = mywxNotebookEvent->GetSelection();
// Looking at method wxNotebookEvent::SetOldSelection
int  * wxNotebookEventSetOldSelectionpage0;
mywxNotebookEvent->SetOldSelection( * wxNotebookEventSetOldSelectionpage0);
// Looking at method wxNotebookEvent::SetSelection
int  * wxNotebookEventSetSelectionpage0;
mywxNotebookEvent->SetSelection( * wxNotebookEventSetSelectionpage0);

// Looking at class wxNotebookSizer
wxNotebookSizer * mywxNotebookSizer;
// Looking at method wxNotebookSizer::wxNotebookSizer
wxNotebook*  * wxNotebookSizerwxNotebookSizernotebook0;
wxNotebookSizer * newwxNotebookSizer0 = new wxNotebookSizer( * wxNotebookSizerwxNotebookSizernotebook0);
// Looking at method wxNotebookSizer::GetNotebook
wxNotebook* retwxNotebookSizerGetNotebook0 = mywxNotebookSizer->GetNotebook();

// Looking at class wxNotifyEvent
wxNotifyEvent * mywxNotifyEvent;
// Looking at method wxNotifyEvent::wxNotifyEvent
wxEventType  * wxNotifyEventwxNotifyEventeventType0;
int  * wxNotifyEventwxNotifyEventid1;
wxNotifyEvent * newwxNotifyEvent0 = new wxNotifyEvent( * wxNotifyEventwxNotifyEventeventType0,  * wxNotifyEventwxNotifyEventid1);
// Looking at method wxNotifyEvent::Allow
mywxNotifyEvent->Allow();
// Looking at method wxNotifyEvent::IsAllowed
bool retwxNotifyEventIsAllowed0 = mywxNotifyEvent->IsAllowed();
// Looking at method wxNotifyEvent::Veto
mywxNotifyEvent->Veto();

// Looking at class wxObject
wxObject * mywxObject;
// Looking at method wxObject::wxObject
wxObject * newwxObject0 = new wxObject();
wxObject  * wxObjectwxObjectother0;
wxObject * newwxObject1 = new wxObject( * wxObjectwxObjectother0);
// Looking at method wxObject::m_refData
// Looking at method wxObject::Dump
ostream  * wxObjectDumpstream0;
mywxObject->Dump( * wxObjectDumpstream0);
// Looking at method wxObject::GetClassInfo
wxClassInfo * retwxObjectGetClassInfo0 = mywxObject->GetClassInfo();
// Looking at method wxObject::GetRefData
wxObjectRefData* retwxObjectGetRefData0 = mywxObject->GetRefData();
// Looking at method wxObject::IsKindOf
wxClassInfo * * wxObjectIsKindOfinfo0;
bool retwxObjectIsKindOf0 = mywxObject->IsKindOf( * wxObjectIsKindOfinfo0);
// Looking at method wxObject::Ref
wxObject  * wxObjectRefclone0;
mywxObject->Ref( * wxObjectRefclone0);
// Looking at method wxObject::SetRefData
wxObjectRefData*  * wxObjectSetRefDatadata0;
mywxObject->SetRefData( * wxObjectSetRefDatadata0);
// Looking at method wxObject::UnRef
mywxObject->UnRef();

// Looking at class wxObjectRefData
wxObjectRefData * mywxObjectRefData;
// Looking at method wxObjectRefData::m_count
// Looking at method wxObjectRefData::wxObjectRefData
wxObjectRefData * newwxObjectRefData0 = new wxObjectRefData();

// Looking at class wxOutputStream
wxOutputStream * mywxOutputStream;
// Looking at method wxOutputStream::wxOutputStream
wxOutputStream * newwxOutputStream0 = new wxOutputStream();
// Looking at method wxOutputStream::Close
bool retwxOutputStreamClose0 = mywxOutputStream->Close();
// Looking at method wxOutputStream::LastWrite
size_t retwxOutputStreamLastWrite0 = mywxOutputStream->LastWrite();
// Looking at method wxOutputStream::PutC
char  * wxOutputStreamPutCc0;
mywxOutputStream->PutC( * wxOutputStreamPutCc0);
// Looking at method wxOutputStream::SeekO
off_t  * wxOutputStreamSeekOpos0;
wxSeekMode  * wxOutputStreamSeekOmode1;
off_t retwxOutputStreamSeekO0 = mywxOutputStream->SeekO( * wxOutputStreamSeekOpos0,  * wxOutputStreamSeekOmode1);
// Looking at method wxOutputStream::TellO
off_t retwxOutputStreamTellO0 = mywxOutputStream->TellO();
// Looking at method wxOutputStream::Write
void * * wxOutputStreamWritebuffer0;
size_t  * wxOutputStreamWritesize1;
wxOutputStream retwxOutputStreamWrite0 = mywxOutputStream->Write( * wxOutputStreamWritebuffer0,  * wxOutputStreamWritesize1);
wxInputStream  * wxOutputStreamWritestream_in2;
wxOutputStream retwxOutputStreamWrite1 = mywxOutputStream->Write( * wxOutputStreamWritestream_in2);

// Looking at class wxPageSetupDialog
wxPageSetupDialog * mywxPageSetupDialog;
// Looking at method wxPageSetupDialog::wxPageSetupDialog
wxWindow*  * wxPageSetupDialogwxPageSetupDialogparent0;
wxPageSetupDialogData*  * wxPageSetupDialogwxPageSetupDialogdata1;
wxPageSetupDialog * newwxPageSetupDialog0 = new wxPageSetupDialog( * wxPageSetupDialogwxPageSetupDialogparent0,  * wxPageSetupDialogwxPageSetupDialogdata1);
// Looking at method wxPageSetupDialog::GetPageSetupData
wxPageSetupDialogData retwxPageSetupDialogGetPageSetupData0 = mywxPageSetupDialog->GetPageSetupData();
// Looking at method wxPageSetupDialog::ShowModal
int retwxPageSetupDialogShowModal0 = mywxPageSetupDialog->ShowModal();

// Looking at class wxPageSetupDialogData
wxPageSetupDialogData * mywxPageSetupDialogData;
// Looking at method wxPageSetupDialogData::wxPageSetupDialogData
wxPageSetupDialogData * newwxPageSetupDialogData0 = new wxPageSetupDialogData();
wxPageSetupDialogData  * wxPageSetupDialogDatawxPageSetupDialogDatadata0;
wxPageSetupDialogData * newwxPageSetupDialogData1 = new wxPageSetupDialogData( * wxPageSetupDialogDatawxPageSetupDialogDatadata0);
wxPrintData  * wxPageSetupDialogDatawxPageSetupDialogDataprintData1;
wxPageSetupDialogData * newwxPageSetupDialogData2 = new wxPageSetupDialogData( * wxPageSetupDialogDatawxPageSetupDialogDataprintData1);
// Looking at method wxPageSetupDialogData::EnableHelp
bool  * wxPageSetupDialogDataEnableHelpflag0;
mywxPageSetupDialogData->EnableHelp( * wxPageSetupDialogDataEnableHelpflag0);
// Looking at method wxPageSetupDialogData::EnableMargins
bool  * wxPageSetupDialogDataEnableMarginsflag0;
mywxPageSetupDialogData->EnableMargins( * wxPageSetupDialogDataEnableMarginsflag0);
// Looking at method wxPageSetupDialogData::EnableOrientation
bool  * wxPageSetupDialogDataEnableOrientationflag0;
mywxPageSetupDialogData->EnableOrientation( * wxPageSetupDialogDataEnableOrientationflag0);
// Looking at method wxPageSetupDialogData::EnablePaper
bool  * wxPageSetupDialogDataEnablePaperflag0;
mywxPageSetupDialogData->EnablePaper( * wxPageSetupDialogDataEnablePaperflag0);
// Looking at method wxPageSetupDialogData::EnablePrinter
bool  * wxPageSetupDialogDataEnablePrinterflag0;
mywxPageSetupDialogData->EnablePrinter( * wxPageSetupDialogDataEnablePrinterflag0);
// Looking at method wxPageSetupDialogData::GetDefaultMinMargins
bool retwxPageSetupDialogDataGetDefaultMinMargins0 = mywxPageSetupDialogData->GetDefaultMinMargins();
// Looking at method wxPageSetupDialogData::GetEnableMargins
bool retwxPageSetupDialogDataGetEnableMargins0 = mywxPageSetupDialogData->GetEnableMargins();
// Looking at method wxPageSetupDialogData::GetEnableOrientation
bool retwxPageSetupDialogDataGetEnableOrientation0 = mywxPageSetupDialogData->GetEnableOrientation();
// Looking at method wxPageSetupDialogData::GetEnablePaper
bool retwxPageSetupDialogDataGetEnablePaper0 = mywxPageSetupDialogData->GetEnablePaper();
// Looking at method wxPageSetupDialogData::GetEnablePrinter
bool retwxPageSetupDialogDataGetEnablePrinter0 = mywxPageSetupDialogData->GetEnablePrinter();
// Looking at method wxPageSetupDialogData::GetEnableHelp
bool retwxPageSetupDialogDataGetEnableHelp0 = mywxPageSetupDialogData->GetEnableHelp();
// Looking at method wxPageSetupDialogData::GetDefaultInfo
bool retwxPageSetupDialogDataGetDefaultInfo0 = mywxPageSetupDialogData->GetDefaultInfo();
// Looking at method wxPageSetupDialogData::GetMarginTopLeft
wxPoint retwxPageSetupDialogDataGetMarginTopLeft0 = mywxPageSetupDialogData->GetMarginTopLeft();
// Looking at method wxPageSetupDialogData::GetMarginBottomRight
wxPoint retwxPageSetupDialogDataGetMarginBottomRight0 = mywxPageSetupDialogData->GetMarginBottomRight();
// Looking at method wxPageSetupDialogData::GetMinMarginTopLeft
wxPoint retwxPageSetupDialogDataGetMinMarginTopLeft0 = mywxPageSetupDialogData->GetMinMarginTopLeft();
// Looking at method wxPageSetupDialogData::GetMinMarginBottomRight
wxPoint retwxPageSetupDialogDataGetMinMarginBottomRight0 = mywxPageSetupDialogData->GetMinMarginBottomRight();
// Looking at method wxPageSetupDialogData::GetPaperId
wxPaperSize retwxPageSetupDialogDataGetPaperId0 = mywxPageSetupDialogData->GetPaperId();
// Looking at method wxPageSetupDialogData::GetPaperSize
wxSize retwxPageSetupDialogDataGetPaperSize0 = mywxPageSetupDialogData->GetPaperSize();
// Looking at method wxPageSetupDialogData::GetPrintData
wxPrintData retwxPageSetupDialogDataGetPrintData0 = mywxPageSetupDialogData->GetPrintData();
// Looking at method wxPageSetupDialogData::Ok
bool retwxPageSetupDialogDataOk0 = mywxPageSetupDialogData->Ok();
// Looking at method wxPageSetupDialogData::SetDefaultInfo
bool  * wxPageSetupDialogDataSetDefaultInfoflag0;
mywxPageSetupDialogData->SetDefaultInfo( * wxPageSetupDialogDataSetDefaultInfoflag0);
// Looking at method wxPageSetupDialogData::SetDefaultMinMargins
bool  * wxPageSetupDialogDataSetDefaultMinMarginsflag0;
mywxPageSetupDialogData->SetDefaultMinMargins( * wxPageSetupDialogDataSetDefaultMinMarginsflag0);
// Looking at method wxPageSetupDialogData::SetMarginTopLeft
wxPoint  * wxPageSetupDialogDataSetMarginTopLeftpt0;
mywxPageSetupDialogData->SetMarginTopLeft( * wxPageSetupDialogDataSetMarginTopLeftpt0);
// Looking at method wxPageSetupDialogData::SetMarginBottomRight
wxPoint  * wxPageSetupDialogDataSetMarginBottomRightpt0;
mywxPageSetupDialogData->SetMarginBottomRight( * wxPageSetupDialogDataSetMarginBottomRightpt0);
// Looking at method wxPageSetupDialogData::SetMinMarginTopLeft
wxPoint  * wxPageSetupDialogDataSetMinMarginTopLeftpt0;
mywxPageSetupDialogData->SetMinMarginTopLeft( * wxPageSetupDialogDataSetMinMarginTopLeftpt0);
// Looking at method wxPageSetupDialogData::SetMinMarginBottomRight
wxPoint  * wxPageSetupDialogDataSetMinMarginBottomRightpt0;
mywxPageSetupDialogData->SetMinMarginBottomRight( * wxPageSetupDialogDataSetMinMarginBottomRightpt0);
// Looking at method wxPageSetupDialogData::SetPaperId
wxPaperSize  * wxPageSetupDialogDataSetPaperIdid0;
mywxPageSetupDialogData->SetPaperId( * wxPageSetupDialogDataSetPaperIdid0);
// Looking at method wxPageSetupDialogData::SetPaperSize
wxSize  * wxPageSetupDialogDataSetPaperSizesize0;
mywxPageSetupDialogData->SetPaperSize( * wxPageSetupDialogDataSetPaperSizesize0);
// Looking at method wxPageSetupDialogData::SetPrintData
wxPrintData  * wxPageSetupDialogDataSetPrintDataprintData0;
mywxPageSetupDialogData->SetPrintData( * wxPageSetupDialogDataSetPrintDataprintData0);

// Looking at class wxPaintDC
wxPaintDC * mywxPaintDC;
// Looking at method wxPaintDC::wxPaintDC
wxWindow*  * wxPaintDCwxPaintDCwindow0;
wxPaintDC * newwxPaintDC0 = new wxPaintDC( * wxPaintDCwxPaintDCwindow0);

// Looking at class wxPaintEvent
wxPaintEvent * mywxPaintEvent;
// Looking at method wxPaintEvent::wxPaintEvent
int  * wxPaintEventwxPaintEventid0;
wxPaintEvent * newwxPaintEvent0 = new wxPaintEvent( * wxPaintEventwxPaintEventid0);

// Looking at class wxPalette
wxPalette * mywxPalette;
// Looking at method wxPalette::wxPalette
wxPalette * newwxPalette0 = new wxPalette();
wxPalette  * wxPalettewxPalettepalette0;
wxPalette * newwxPalette1 = new wxPalette( * wxPalettewxPalettepalette0);
int  * wxPalettewxPaletten1;
unsigned char*  * wxPalettewxPalettered2;
unsigned char*  * wxPalettewxPalettegreen3;
unsigned char*  * wxPalettewxPaletteblue4;
wxPalette * newwxPalette2 = new wxPalette( * wxPalettewxPaletten1,  * wxPalettewxPalettered2,  * wxPalettewxPalettegreen3,  * wxPalettewxPaletteblue4);
// Looking at method wxPalette::Create
int  * wxPaletteCreaten0;
unsigned char*  * wxPaletteCreatered1;
unsigned char*  * wxPaletteCreategreen2;
unsigned char*  * wxPaletteCreateblue3;
bool retwxPaletteCreate0 = mywxPalette->Create( * wxPaletteCreaten0,  * wxPaletteCreatered1,  * wxPaletteCreategreen2,  * wxPaletteCreateblue3);
// Looking at method wxPalette::GetColoursCount
int retwxPaletteGetColoursCount0 = mywxPalette->GetColoursCount();
// Looking at method wxPalette::GetPixel
unsigned char  * wxPaletteGetPixelred0;
unsigned char  * wxPaletteGetPixelgreen1;
unsigned char  * wxPaletteGetPixelblue2;
int retwxPaletteGetPixel0 = mywxPalette->GetPixel( * wxPaletteGetPixelred0,  * wxPaletteGetPixelgreen1,  * wxPaletteGetPixelblue2);
// Looking at method wxPalette::GetRGB
int  * wxPaletteGetRGBpixel0;
unsigned char*  * wxPaletteGetRGBred1;
unsigned char*  * wxPaletteGetRGBgreen2;
unsigned char*  * wxPaletteGetRGBblue3;
bool retwxPaletteGetRGB0 = mywxPalette->GetRGB( * wxPaletteGetRGBpixel0,  * wxPaletteGetRGBred1,  * wxPaletteGetRGBgreen2,  * wxPaletteGetRGBblue3);
// Looking at method wxPalette::Ok
bool retwxPaletteOk0 = mywxPalette->Ok();

// Looking at class wxPanel
wxPanel * mywxPanel;
// Looking at method wxPanel::wxPanel
wxPanel * newwxPanel0 = new wxPanel();
wxWindow*  * wxPanelwxPanelparent0;
wxWindowID  * wxPanelwxPanelid1;
wxPoint  * wxPanelwxPanelpos2;
wxSize  * wxPanelwxPanelsize3;
long  * wxPanelwxPanelstyle4;
wxString  * wxPanelwxPanelname5;
wxPanel * newwxPanel1 = new wxPanel( * wxPanelwxPanelparent0,  * wxPanelwxPanelid1,  * wxPanelwxPanelpos2,  * wxPanelwxPanelsize3,  * wxPanelwxPanelstyle4,  * wxPanelwxPanelname5);
// Looking at method wxPanel::Create
wxWindow*  * wxPanelCreateparent0;
wxWindowID  * wxPanelCreateid1;
wxPoint  * wxPanelCreatepos2;
wxSize  * wxPanelCreatesize3;
long  * wxPanelCreatestyle4;
wxString  * wxPanelCreatename5;
bool retwxPanelCreate0 = mywxPanel->Create( * wxPanelCreateparent0,  * wxPanelCreateid1,  * wxPanelCreatepos2,  * wxPanelCreatesize3,  * wxPanelCreatestyle4,  * wxPanelCreatename5);
// Looking at method wxPanel::GetDefaultItem
wxWindow* retwxPanelGetDefaultItem0 = mywxPanel->GetDefaultItem();
// Looking at method wxPanel::InitDialog
mywxPanel->InitDialog();
// Looking at method wxPanel::OnSysColourChanged
wxSysColourChangedEvent  * wxPanelOnSysColourChangedevent0;
mywxPanel->OnSysColourChanged( * wxPanelOnSysColourChangedevent0);
// Looking at method wxPanel::SetDefaultItem
wxButton * * wxPanelSetDefaultItembtn0;
mywxPanel->SetDefaultItem( * wxPanelSetDefaultItembtn0);
// Looking at method wxPanel::SetFocus
// Looking at method wxPanel::SetFocusIgnoringChildren

// Looking at class wxPasswordEntryDialog
wxPasswordEntryDialog * mywxPasswordEntryDialog;
// Looking at method wxPasswordEntryDialog::wxPasswordEntryDialog
wxWindow*  * wxPasswordEntryDialogwxPasswordEntryDialogparent0;
wxString  * wxPasswordEntryDialogwxPasswordEntryDialogmessage1;
wxString  * wxPasswordEntryDialogwxPasswordEntryDialogcaption2;
wxString  * wxPasswordEntryDialogwxPasswordEntryDialogdefaultValue3;
long  * wxPasswordEntryDialogwxPasswordEntryDialogstyle4;
wxPoint  * wxPasswordEntryDialogwxPasswordEntryDialogpos5;
wxPasswordEntryDialog * newwxPasswordEntryDialog0 = new wxPasswordEntryDialog( * wxPasswordEntryDialogwxPasswordEntryDialogparent0,  * wxPasswordEntryDialogwxPasswordEntryDialogmessage1,  * wxPasswordEntryDialogwxPasswordEntryDialogcaption2,  * wxPasswordEntryDialogwxPasswordEntryDialogdefaultValue3,  * wxPasswordEntryDialogwxPasswordEntryDialogstyle4,  * wxPasswordEntryDialogwxPasswordEntryDialogpos5);

// Looking at class wxPathList
wxPathList * mywxPathList;
// Looking at method wxPathList::wxPathList
wxPathList * newwxPathList0 = new wxPathList();
// Looking at method wxPathList::AddEnvList
wxString  * wxPathListAddEnvListenv_variable0;
mywxPathList->AddEnvList( * wxPathListAddEnvListenv_variable0);
// Looking at method wxPathList::Add
wxString  * wxPathListAddpath0;
mywxPathList->Add( * wxPathListAddpath0);
// Looking at method wxPathList::EnsureFileAccessible
wxString  * wxPathListEnsureFileAccessiblefilename0;
mywxPathList->EnsureFileAccessible( * wxPathListEnsureFileAccessiblefilename0);
// Looking at method wxPathList::FindAbsoluteValidPath
wxString  * wxPathListFindAbsoluteValidPathfile0;
wxString retwxPathListFindAbsoluteValidPath0 = mywxPathList->FindAbsoluteValidPath( * wxPathListFindAbsoluteValidPathfile0);
// Looking at method wxPathList::FindValidPath
wxString  * wxPathListFindValidPathfile0;
wxString retwxPathListFindValidPath0 = mywxPathList->FindValidPath( * wxPathListFindValidPathfile0);
// Looking at method wxPathList::Member
wxString  * wxPathListMemberfile0;
bool retwxPathListMember0 = mywxPathList->Member( * wxPathListMemberfile0);

// Looking at class wxPen
wxPen * mywxPen;
// Looking at method wxPen::wxPen
wxPen * newwxPen0 = new wxPen();
wxColour  * wxPenwxPencolour0;
int  * wxPenwxPenwidth1;
int  * wxPenwxPenstyle2;
wxPen * newwxPen1 = new wxPen( * wxPenwxPencolour0,  * wxPenwxPenwidth1,  * wxPenwxPenstyle2);
wxString  * wxPenwxPencolourName3;
int  * wxPenwxPenwidth4;
int  * wxPenwxPenstyle5;
wxPen * newwxPen2 = new wxPen( * wxPenwxPencolourName3,  * wxPenwxPenwidth4,  * wxPenwxPenstyle5);
wxBitmap  * wxPenwxPenstipple6;
int  * wxPenwxPenwidth7;
wxPen * newwxPen3 = new wxPen( * wxPenwxPenstipple6,  * wxPenwxPenwidth7);
wxPen  * wxPenwxPenpen8;
wxPen * newwxPen4 = new wxPen( * wxPenwxPenpen8);
// Looking at method wxPen::GetCap
int retwxPenGetCap0 = mywxPen->GetCap();
// Looking at method wxPen::GetColour
wxColour retwxPenGetColour0 = mywxPen->GetColour();
// Looking at method wxPen::GetDashes
wxDash**  * wxPenGetDashesdashes0;
int retwxPenGetDashes0 = mywxPen->GetDashes( * wxPenGetDashesdashes0);
// Looking at method wxPen::GetJoin
int retwxPenGetJoin0 = mywxPen->GetJoin();
// Looking at method wxPen::GetStipple
wxBitmap*  retwxPenGetStipple0 = mywxPen->GetStipple();
// Looking at method wxPen::GetStyle
int retwxPenGetStyle0 = mywxPen->GetStyle();
// Looking at method wxPen::GetWidth
int retwxPenGetWidth0 = mywxPen->GetWidth();
// Looking at method wxPen::Ok
bool retwxPenOk0 = mywxPen->Ok();
// Looking at method wxPen::SetCap
int  * wxPenSetCapcapStyle0;
mywxPen->SetCap( * wxPenSetCapcapStyle0);
// Looking at method wxPen::SetColour
wxColour  * wxPenSetColourcolour0;
mywxPen->SetColour( * wxPenSetColourcolour0);
wxString  * wxPenSetColourcolourName1;
mywxPen->SetColour( * wxPenSetColourcolourName1);
int  * wxPenSetColourred2;
int  * wxPenSetColourgreen3;
int  * wxPenSetColourblue4;
mywxPen->SetColour( * wxPenSetColourred2,  * wxPenSetColourgreen3,  * wxPenSetColourblue4);
// Looking at method wxPen::SetDashes
int  * wxPenSetDashesn0;
wxDash*  * wxPenSetDashesdashes1;
mywxPen->SetDashes( * wxPenSetDashesn0,  * wxPenSetDashesdashes1);
// Looking at method wxPen::SetJoin
int  * wxPenSetJoinjoin_style0;
mywxPen->SetJoin( * wxPenSetJoinjoin_style0);
// Looking at method wxPen::SetStipple
wxBitmap*  * wxPenSetStipplestipple0;
mywxPen->SetStipple( * wxPenSetStipplestipple0);
// Looking at method wxPen::SetStyle
int  * wxPenSetStylestyle0;
mywxPen->SetStyle( * wxPenSetStylestyle0);
// Looking at method wxPen::SetWidth
int  * wxPenSetWidthwidth0;
mywxPen->SetWidth( * wxPenSetWidthwidth0);

// Looking at class wxPenList
wxPenList * mywxPenList;
// Looking at method wxPenList::wxPenList
wxPenList * newwxPenList0 = new wxPenList();
// Looking at method wxPenList::AddPen
wxPen*  * wxPenListAddPenpen0;
mywxPenList->AddPen( * wxPenListAddPenpen0);
// Looking at method wxPenList::FindOrCreatePen
wxColour  * wxPenListFindOrCreatePencolour0;
int  * wxPenListFindOrCreatePenwidth1;
int  * wxPenListFindOrCreatePenstyle2;
wxPen* retwxPenListFindOrCreatePen0 = mywxPenList->FindOrCreatePen( * wxPenListFindOrCreatePencolour0,  * wxPenListFindOrCreatePenwidth1,  * wxPenListFindOrCreatePenstyle2);
wxString  * wxPenListFindOrCreatePencolourName3;
int  * wxPenListFindOrCreatePenwidth4;
int  * wxPenListFindOrCreatePenstyle5;
wxPen* retwxPenListFindOrCreatePen1 = mywxPenList->FindOrCreatePen( * wxPenListFindOrCreatePencolourName3,  * wxPenListFindOrCreatePenwidth4,  * wxPenListFindOrCreatePenstyle5);
// Looking at method wxPenList::RemovePen
wxPen*  * wxPenListRemovePenpen0;
mywxPenList->RemovePen( * wxPenListRemovePenpen0);

// Looking at class wxPoint
wxPoint * mywxPoint;
// Looking at method wxPoint::wxPoint
wxPoint * newwxPoint0 = new wxPoint();
int  * wxPointwxPointx0;
int  * wxPointwxPointy1;
wxPoint * newwxPoint1 = new wxPoint( * wxPointwxPointx0,  * wxPointwxPointy1);
// Looking at method wxPoint::x
// Looking at method wxPoint::y

// Looking at class wxPostScriptDC
wxPostScriptDC * mywxPostScriptDC;
// Looking at method wxPostScriptDC::wxPostScriptDC
wxPrintData  * wxPostScriptDCwxPostScriptDCprintData0;
wxPostScriptDC * newwxPostScriptDC0 = new wxPostScriptDC( * wxPostScriptDCwxPostScriptDCprintData0);
wxString  * wxPostScriptDCwxPostScriptDCoutput1;
bool  * wxPostScriptDCwxPostScriptDCinteractive2;
wxWindow * * wxPostScriptDCwxPostScriptDCparent3;
wxPostScriptDC * newwxPostScriptDC1 = new wxPostScriptDC( * wxPostScriptDCwxPostScriptDCoutput1,  * wxPostScriptDCwxPostScriptDCinteractive2,  * wxPostScriptDCwxPostScriptDCparent3);
// Looking at method wxPostScriptDC::SetResolution
int  * wxPostScriptDCSetResolutionppi0;
mywxPostScriptDC->SetResolution( * wxPostScriptDCSetResolutionppi0);
// Looking at method wxPostScriptDC::GetResolution
static int retwxPostScriptDCGetResolution0 = mywxPostScriptDC->GetResolution();

// Looking at class wxPreviewCanvas
wxPreviewCanvas * mywxPreviewCanvas;
// Looking at method wxPreviewCanvas::wxPreviewCanvas
wxPrintPreview*  * wxPreviewCanvaswxPreviewCanvaspreview0;
wxWindow*  * wxPreviewCanvaswxPreviewCanvasparent1;
wxPoint  * wxPreviewCanvaswxPreviewCanvaspos2;
wxSize  * wxPreviewCanvaswxPreviewCanvassize3;
long  * wxPreviewCanvaswxPreviewCanvasstyle4;
wxString  * wxPreviewCanvaswxPreviewCanvasname5;
wxPreviewCanvas * newwxPreviewCanvas0 = new wxPreviewCanvas( * wxPreviewCanvaswxPreviewCanvaspreview0,  * wxPreviewCanvaswxPreviewCanvasparent1,  * wxPreviewCanvaswxPreviewCanvaspos2,  * wxPreviewCanvaswxPreviewCanvassize3,  * wxPreviewCanvaswxPreviewCanvasstyle4,  * wxPreviewCanvaswxPreviewCanvasname5);
// Looking at method wxPreviewCanvas::OnPaint
wxPaintEvent  * wxPreviewCanvasOnPaintevent0;
mywxPreviewCanvas->OnPaint( * wxPreviewCanvasOnPaintevent0);

// Looking at class wxPreviewControlBar
wxPreviewControlBar * mywxPreviewControlBar;
// Looking at method wxPreviewControlBar::wxPreviewControlBar
wxPrintPreview*  * wxPreviewControlBarwxPreviewControlBarpreview0;
long  * wxPreviewControlBarwxPreviewControlBarbuttons1;
wxWindow*  * wxPreviewControlBarwxPreviewControlBarparent2;
wxPoint  * wxPreviewControlBarwxPreviewControlBarpos3;
wxSize  * wxPreviewControlBarwxPreviewControlBarsize4;
long  * wxPreviewControlBarwxPreviewControlBarstyle5;
wxString  * wxPreviewControlBarwxPreviewControlBarname6;
wxPreviewControlBar * newwxPreviewControlBar0 = new wxPreviewControlBar( * wxPreviewControlBarwxPreviewControlBarpreview0,  * wxPreviewControlBarwxPreviewControlBarbuttons1,  * wxPreviewControlBarwxPreviewControlBarparent2,  * wxPreviewControlBarwxPreviewControlBarpos3,  * wxPreviewControlBarwxPreviewControlBarsize4,  * wxPreviewControlBarwxPreviewControlBarstyle5,  * wxPreviewControlBarwxPreviewControlBarname6);
// Looking at method wxPreviewControlBar::CreateButtons
mywxPreviewControlBar->CreateButtons();
// Looking at method wxPreviewControlBar::GetPrintPreview
wxPrintPreview * retwxPreviewControlBarGetPrintPreview0 = mywxPreviewControlBar->GetPrintPreview();
// Looking at method wxPreviewControlBar::GetZoomControl
int retwxPreviewControlBarGetZoomControl0 = mywxPreviewControlBar->GetZoomControl();
// Looking at method wxPreviewControlBar::SetZoomControl
int  * wxPreviewControlBarSetZoomControlpercent0;
mywxPreviewControlBar->SetZoomControl( * wxPreviewControlBarSetZoomControlpercent0);

// Looking at class wxPreviewFrame
wxPreviewFrame * mywxPreviewFrame;
// Looking at method wxPreviewFrame::wxPreviewFrame
wxPrintPreview*  * wxPreviewFramewxPreviewFramepreview0;
wxWindow*  * wxPreviewFramewxPreviewFrameparent1;
wxString  * wxPreviewFramewxPreviewFrametitle2;
wxPoint  * wxPreviewFramewxPreviewFramepos3;
wxSize  * wxPreviewFramewxPreviewFramesize4;
long  * wxPreviewFramewxPreviewFramestyle5;
wxString  * wxPreviewFramewxPreviewFramename6;
wxPreviewFrame * newwxPreviewFrame0 = new wxPreviewFrame( * wxPreviewFramewxPreviewFramepreview0,  * wxPreviewFramewxPreviewFrameparent1,  * wxPreviewFramewxPreviewFrametitle2,  * wxPreviewFramewxPreviewFramepos3,  * wxPreviewFramewxPreviewFramesize4,  * wxPreviewFramewxPreviewFramestyle5,  * wxPreviewFramewxPreviewFramename6);
// Looking at method wxPreviewFrame::CreateControlBar
mywxPreviewFrame->CreateControlBar();
// Looking at method wxPreviewFrame::CreateCanvas
mywxPreviewFrame->CreateCanvas();
// Looking at method wxPreviewFrame::Initialize
mywxPreviewFrame->Initialize();
// Looking at method wxPreviewFrame::OnCloseWindow
wxCloseEvent  * wxPreviewFrameOnCloseWindowevent0;
mywxPreviewFrame->OnCloseWindow( * wxPreviewFrameOnCloseWindowevent0);

// Looking at class wxPrintData
wxPrintData * mywxPrintData;
// Looking at method wxPrintData::wxPrintData
wxPrintData * newwxPrintData0 = new wxPrintData();
wxPrintData  * wxPrintDatawxPrintDatadata0;
wxPrintData * newwxPrintData1 = new wxPrintData( * wxPrintDatawxPrintDatadata0);
// Looking at method wxPrintData::GetCollate
bool retwxPrintDataGetCollate0 = mywxPrintData->GetCollate();
// Looking at method wxPrintData::GetBin
wxPrintBin retwxPrintDataGetBin0 = mywxPrintData->GetBin();
// Looking at method wxPrintData::GetColour
bool retwxPrintDataGetColour0 = mywxPrintData->GetColour();
// Looking at method wxPrintData::GetDuplex
wxDuplexMode retwxPrintDataGetDuplex0 = mywxPrintData->GetDuplex();
// Looking at method wxPrintData::GetNoCopies
int retwxPrintDataGetNoCopies0 = mywxPrintData->GetNoCopies();
// Looking at method wxPrintData::GetOrientation
int retwxPrintDataGetOrientation0 = mywxPrintData->GetOrientation();
// Looking at method wxPrintData::GetPaperId
wxPaperSize retwxPrintDataGetPaperId0 = mywxPrintData->GetPaperId();
// Looking at method wxPrintData::GetPrinterName
const wxString retwxPrintDataGetPrinterName0 = mywxPrintData->GetPrinterName();
// Looking at method wxPrintData::GetQuality
wxPrintQuality retwxPrintDataGetQuality0 = mywxPrintData->GetQuality();
// Looking at method wxPrintData::Ok
bool retwxPrintDataOk0 = mywxPrintData->Ok();
// Looking at method wxPrintData::SetBin
wxPrintBin  * wxPrintDataSetBinflag0;
mywxPrintData->SetBin( * wxPrintDataSetBinflag0);
// Looking at method wxPrintData::SetCollate
bool  * wxPrintDataSetCollateflag0;
mywxPrintData->SetCollate( * wxPrintDataSetCollateflag0);
// Looking at method wxPrintData::SetColour
bool  * wxPrintDataSetColourflag0;
mywxPrintData->SetColour( * wxPrintDataSetColourflag0);
// Looking at method wxPrintData::SetDuplex
wxDuplexMode  * wxPrintDataSetDuplexmode0;
mywxPrintData->SetDuplex( * wxPrintDataSetDuplexmode0);
// Looking at method wxPrintData::SetNoCopies
int  * wxPrintDataSetNoCopiesn0;
mywxPrintData->SetNoCopies( * wxPrintDataSetNoCopiesn0);
// Looking at method wxPrintData::SetOrientation
int  * wxPrintDataSetOrientationorientation0;
mywxPrintData->SetOrientation( * wxPrintDataSetOrientationorientation0);
// Looking at method wxPrintData::SetPaperId
wxPaperSize  * wxPrintDataSetPaperIdpaperId0;
mywxPrintData->SetPaperId( * wxPrintDataSetPaperIdpaperId0);
// Looking at method wxPrintData::SetPrinterName
wxString  * wxPrintDataSetPrinterNameprinterName0;
mywxPrintData->SetPrinterName( * wxPrintDataSetPrinterNameprinterName0);
// Looking at method wxPrintData::SetQuality
wxPrintQuality  * wxPrintDataSetQualityquality0;
mywxPrintData->SetQuality( * wxPrintDataSetQualityquality0);

// Looking at class wxPrintDialog
wxPrintDialog * mywxPrintDialog;
// Looking at method wxPrintDialog::wxPrintDialog
wxWindow*  * wxPrintDialogwxPrintDialogparent0;
wxPrintDialogData*  * wxPrintDialogwxPrintDialogdata1;
wxPrintDialog * newwxPrintDialog0 = new wxPrintDialog( * wxPrintDialogwxPrintDialogparent0,  * wxPrintDialogwxPrintDialogdata1);
// Looking at method wxPrintDialog::GetPrintDialogData
wxPrintDialogData retwxPrintDialogGetPrintDialogData0 = mywxPrintDialog->GetPrintDialogData();
// Looking at method wxPrintDialog::GetPrintDC
wxDC*  retwxPrintDialogGetPrintDC0 = mywxPrintDialog->GetPrintDC();
// Looking at method wxPrintDialog::ShowModal
int retwxPrintDialogShowModal0 = mywxPrintDialog->ShowModal();

// Looking at class wxPrintDialogData
wxPrintDialogData * mywxPrintDialogData;
// Looking at method wxPrintDialogData::wxPrintDialogData
wxPrintDialogData * newwxPrintDialogData0 = new wxPrintDialogData();
wxPrintDialogData  * wxPrintDialogDatawxPrintDialogDatadialogData0;
wxPrintDialogData * newwxPrintDialogData1 = new wxPrintDialogData( * wxPrintDialogDatawxPrintDialogDatadialogData0);
wxPrintData  * wxPrintDialogDatawxPrintDialogDataprintData1;
wxPrintDialogData * newwxPrintDialogData2 = new wxPrintDialogData( * wxPrintDialogDatawxPrintDialogDataprintData1);
// Looking at method wxPrintDialogData::EnableHelp
bool  * wxPrintDialogDataEnableHelpflag0;
mywxPrintDialogData->EnableHelp( * wxPrintDialogDataEnableHelpflag0);
// Looking at method wxPrintDialogData::EnablePageNumbers
bool  * wxPrintDialogDataEnablePageNumbersflag0;
mywxPrintDialogData->EnablePageNumbers( * wxPrintDialogDataEnablePageNumbersflag0);
// Looking at method wxPrintDialogData::EnablePrintToFile
bool  * wxPrintDialogDataEnablePrintToFileflag0;
mywxPrintDialogData->EnablePrintToFile( * wxPrintDialogDataEnablePrintToFileflag0);
// Looking at method wxPrintDialogData::EnableSelection
bool  * wxPrintDialogDataEnableSelectionflag0;
mywxPrintDialogData->EnableSelection( * wxPrintDialogDataEnableSelectionflag0);
// Looking at method wxPrintDialogData::GetAllPages
bool retwxPrintDialogDataGetAllPages0 = mywxPrintDialogData->GetAllPages();
// Looking at method wxPrintDialogData::GetCollate
bool retwxPrintDialogDataGetCollate0 = mywxPrintDialogData->GetCollate();
// Looking at method wxPrintDialogData::GetFromPage
int retwxPrintDialogDataGetFromPage0 = mywxPrintDialogData->GetFromPage();
// Looking at method wxPrintDialogData::GetMaxPage
int retwxPrintDialogDataGetMaxPage0 = mywxPrintDialogData->GetMaxPage();
// Looking at method wxPrintDialogData::GetMinPage
int retwxPrintDialogDataGetMinPage0 = mywxPrintDialogData->GetMinPage();
// Looking at method wxPrintDialogData::GetNoCopies
int retwxPrintDialogDataGetNoCopies0 = mywxPrintDialogData->GetNoCopies();
// Looking at method wxPrintDialogData::GetPrintData
wxPrintData retwxPrintDialogDataGetPrintData0 = mywxPrintDialogData->GetPrintData();
// Looking at method wxPrintDialogData::GetPrintToFile
bool retwxPrintDialogDataGetPrintToFile0 = mywxPrintDialogData->GetPrintToFile();
// Looking at method wxPrintDialogData::GetSelection
bool retwxPrintDialogDataGetSelection0 = mywxPrintDialogData->GetSelection();
// Looking at method wxPrintDialogData::GetToPage
int retwxPrintDialogDataGetToPage0 = mywxPrintDialogData->GetToPage();
// Looking at method wxPrintDialogData::Ok
bool retwxPrintDialogDataOk0 = mywxPrintDialogData->Ok();
// Looking at method wxPrintDialogData::SetCollate
bool  * wxPrintDialogDataSetCollateflag0;
mywxPrintDialogData->SetCollate( * wxPrintDialogDataSetCollateflag0);
// Looking at method wxPrintDialogData::SetFromPage
int  * wxPrintDialogDataSetFromPagepage0;
mywxPrintDialogData->SetFromPage( * wxPrintDialogDataSetFromPagepage0);
// Looking at method wxPrintDialogData::SetMaxPage
int  * wxPrintDialogDataSetMaxPagepage0;
mywxPrintDialogData->SetMaxPage( * wxPrintDialogDataSetMaxPagepage0);
// Looking at method wxPrintDialogData::SetMinPage
int  * wxPrintDialogDataSetMinPagepage0;
mywxPrintDialogData->SetMinPage( * wxPrintDialogDataSetMinPagepage0);
// Looking at method wxPrintDialogData::SetNoCopies
int  * wxPrintDialogDataSetNoCopiesn0;
mywxPrintDialogData->SetNoCopies( * wxPrintDialogDataSetNoCopiesn0);
// Looking at method wxPrintDialogData::SetPrintData
wxPrintData  * wxPrintDialogDataSetPrintDataprintData0;
mywxPrintDialogData->SetPrintData( * wxPrintDialogDataSetPrintDataprintData0);
// Looking at method wxPrintDialogData::SetPrintToFile
bool  * wxPrintDialogDataSetPrintToFileflag0;
mywxPrintDialogData->SetPrintToFile( * wxPrintDialogDataSetPrintToFileflag0);
// Looking at method wxPrintDialogData::SetSelection
bool  * wxPrintDialogDataSetSelectionflag0;
mywxPrintDialogData->SetSelection( * wxPrintDialogDataSetSelectionflag0);
// Looking at method wxPrintDialogData::SetSetupDialog
bool  * wxPrintDialogDataSetSetupDialogflag0;
mywxPrintDialogData->SetSetupDialog( * wxPrintDialogDataSetSetupDialogflag0);
// Looking at method wxPrintDialogData::SetToPage
int  * wxPrintDialogDataSetToPagepage0;
mywxPrintDialogData->SetToPage( * wxPrintDialogDataSetToPagepage0);

// Looking at class wxPrintPreview
wxPrintPreview * mywxPrintPreview;
// Looking at method wxPrintPreview::wxPrintPreview
wxPrintout*  * wxPrintPreviewwxPrintPreviewprintout0;
wxPrintout*  * wxPrintPreviewwxPrintPreviewprintoutForPrinting1;
wxPrintData*  * wxPrintPreviewwxPrintPreviewdata2;
wxPrintPreview * newwxPrintPreview0 = new wxPrintPreview( * wxPrintPreviewwxPrintPreviewprintout0,  * wxPrintPreviewwxPrintPreviewprintoutForPrinting1,  * wxPrintPreviewwxPrintPreviewdata2);
// Looking at method wxPrintPreview::GetCanvas
wxPreviewCanvas*  retwxPrintPreviewGetCanvas0 = mywxPrintPreview->GetCanvas();
// Looking at method wxPrintPreview::GetCurrentPage
int retwxPrintPreviewGetCurrentPage0 = mywxPrintPreview->GetCurrentPage();
// Looking at method wxPrintPreview::GetFrame
wxFrame * retwxPrintPreviewGetFrame0 = mywxPrintPreview->GetFrame();
// Looking at method wxPrintPreview::GetMaxPage
int retwxPrintPreviewGetMaxPage0 = mywxPrintPreview->GetMaxPage();
// Looking at method wxPrintPreview::GetMinPage
int retwxPrintPreviewGetMinPage0 = mywxPrintPreview->GetMinPage();
// Looking at method wxPrintPreview::GetPrintout
wxPrintout * retwxPrintPreviewGetPrintout0 = mywxPrintPreview->GetPrintout();
// Looking at method wxPrintPreview::GetPrintoutForPrinting
wxPrintout * retwxPrintPreviewGetPrintoutForPrinting0 = mywxPrintPreview->GetPrintoutForPrinting();
// Looking at method wxPrintPreview::Ok
bool retwxPrintPreviewOk0 = mywxPrintPreview->Ok();
// Looking at method wxPrintPreview::PaintPage
wxPreviewCanvas * * wxPrintPreviewPaintPagecanvas0;
wxDC  * wxPrintPreviewPaintPagedc1;
bool retwxPrintPreviewPaintPage0 = mywxPrintPreview->PaintPage( * wxPrintPreviewPaintPagecanvas0,  * wxPrintPreviewPaintPagedc1);
// Looking at method wxPrintPreview::Print
bool  * wxPrintPreviewPrintprompt0;
bool retwxPrintPreviewPrint0 = mywxPrintPreview->Print( * wxPrintPreviewPrintprompt0);
// Looking at method wxPrintPreview::RenderPage
int  * wxPrintPreviewRenderPagepageNum0;
bool retwxPrintPreviewRenderPage0 = mywxPrintPreview->RenderPage( * wxPrintPreviewRenderPagepageNum0);
// Looking at method wxPrintPreview::SetCanvas
wxPreviewCanvas*  * wxPrintPreviewSetCanvaswindow0;
mywxPrintPreview->SetCanvas( * wxPrintPreviewSetCanvaswindow0);
// Looking at method wxPrintPreview::SetCurrentPage
int  * wxPrintPreviewSetCurrentPagepageNum0;
mywxPrintPreview->SetCurrentPage( * wxPrintPreviewSetCurrentPagepageNum0);
// Looking at method wxPrintPreview::SetFrame
wxFrame * * wxPrintPreviewSetFrameframe0;
mywxPrintPreview->SetFrame( * wxPrintPreviewSetFrameframe0);
// Looking at method wxPrintPreview::SetPrintout
wxPrintout * * wxPrintPreviewSetPrintoutprintout0;
mywxPrintPreview->SetPrintout( * wxPrintPreviewSetPrintoutprintout0);
// Looking at method wxPrintPreview::SetZoom
int  * wxPrintPreviewSetZoompercent0;
mywxPrintPreview->SetZoom( * wxPrintPreviewSetZoompercent0);

// Looking at class wxPrinter
wxPrinter * mywxPrinter;
// Looking at method wxPrinter::wxPrinter
wxPrintDialogData*  * wxPrinterwxPrinterdata0;
wxPrinter * newwxPrinter0 = new wxPrinter( * wxPrinterwxPrinterdata0);
// Looking at method wxPrinter::CreateAbortWindow
wxWindow*  * wxPrinterCreateAbortWindowparent0;
wxPrintout*  * wxPrinterCreateAbortWindowprintout1;
mywxPrinter->CreateAbortWindow( * wxPrinterCreateAbortWindowparent0,  * wxPrinterCreateAbortWindowprintout1);
// Looking at method wxPrinter::GetAbort
bool retwxPrinterGetAbort0 = mywxPrinter->GetAbort();
// Looking at method wxPrinter::GetLastError
static wxPrinterError retwxPrinterGetLastError0 = mywxPrinter->GetLastError();
// Looking at method wxPrinter::GetPrintDialogData
wxPrintDialogData retwxPrinterGetPrintDialogData0 = mywxPrinter->GetPrintDialogData();
// Looking at method wxPrinter::Print
wxWindow * * wxPrinterPrintparent0;
wxPrintout * * wxPrinterPrintprintout1;
bool  * wxPrinterPrintprompt2;
bool retwxPrinterPrint0 = mywxPrinter->Print( * wxPrinterPrintparent0,  * wxPrinterPrintprintout1,  * wxPrinterPrintprompt2);
// Looking at method wxPrinter::PrintDialog
wxWindow * * wxPrinterPrintDialogparent0;
wxDC* retwxPrinterPrintDialog0 = mywxPrinter->PrintDialog( * wxPrinterPrintDialogparent0);
// Looking at method wxPrinter::ReportError
wxWindow * * wxPrinterReportErrorparent0;
wxPrintout * * wxPrinterReportErrorprintout1;
wxString  * wxPrinterReportErrormessage2;
mywxPrinter->ReportError( * wxPrinterReportErrorparent0,  * wxPrinterReportErrorprintout1,  * wxPrinterReportErrormessage2);
// Looking at method wxPrinter::Setup
wxWindow * * wxPrinterSetupparent0;
bool retwxPrinterSetup0 = mywxPrinter->Setup( * wxPrinterSetupparent0);

// Looking at class wxProcess
wxProcess * mywxProcess;
// Looking at method wxProcess::wxProcess
wxEvtHandler *  * wxProcesswxProcessparent0;
int  * wxProcesswxProcessid1;
wxProcess * newwxProcess0 = new wxProcess( * wxProcesswxProcessparent0,  * wxProcesswxProcessid1);
int  * wxProcesswxProcessflags2;
wxProcess * newwxProcess1 = new wxProcess( * wxProcesswxProcessflags2);
// Looking at method wxProcess::CloseOutput
mywxProcess->CloseOutput();
// Looking at method wxProcess::Detach
mywxProcess->Detach();
// Looking at method wxProcess::GetErrorStream
wxInputStream*  retwxProcessGetErrorStream0 = mywxProcess->GetErrorStream();
// Looking at method wxProcess::GetInputStream
wxInputStream*  retwxProcessGetInputStream0 = mywxProcess->GetInputStream();
// Looking at method wxProcess::GetOutputStream
wxOutputStream*  retwxProcessGetOutputStream0 = mywxProcess->GetOutputStream();
// Looking at method wxProcess::IsErrorAvailable
bool retwxProcessIsErrorAvailable0 = mywxProcess->IsErrorAvailable();
// Looking at method wxProcess::IsInputAvailable
bool retwxProcessIsInputAvailable0 = mywxProcess->IsInputAvailable();
// Looking at method wxProcess::IsInputOpened
bool retwxProcessIsInputOpened0 = mywxProcess->IsInputOpened();
// Looking at method wxProcess::Kill
int  * wxProcessKillpid0;
wxSignal  * wxProcessKillsignal1;
int  * wxProcessKillflags2;
static wxKillError retwxProcessKill0 = mywxProcess->Kill( * wxProcessKillpid0,  * wxProcessKillsignal1,  * wxProcessKillflags2);
// Looking at method wxProcess::Exists
int  * wxProcessExistspid0;
static bool retwxProcessExists0 = mywxProcess->Exists( * wxProcessExistspid0);
// Looking at method wxProcess::OnTerminate
int  * wxProcessOnTerminatepid0;
int  * wxProcessOnTerminatestatus1;
mywxProcess->OnTerminate( * wxProcessOnTerminatepid0,  * wxProcessOnTerminatestatus1);
// Looking at method wxProcess::Open
wxString  * wxProcessOpencmd0;
int  * wxProcessOpenflags1;
static wxProcess * retwxProcessOpen0 = mywxProcess->Open( * wxProcessOpencmd0,  * wxProcessOpenflags1);
// Looking at method wxProcess::Redirect
mywxProcess->Redirect();

// Looking at class wxProcessEvent
wxProcessEvent * mywxProcessEvent;
// Looking at method wxProcessEvent::wxProcessEvent
int  * wxProcessEventwxProcessEventid0;
int  * wxProcessEventwxProcessEventpid1;
int  * wxProcessEventwxProcessEventexitcode2;
wxProcessEvent * newwxProcessEvent0 = new wxProcessEvent( * wxProcessEventwxProcessEventid0,  * wxProcessEventwxProcessEventpid1,  * wxProcessEventwxProcessEventexitcode2);
// Looking at method wxProcessEvent::GetPid
int retwxProcessEventGetPid0 = mywxProcessEvent->GetPid();
// Looking at method wxProcessEvent::GetExitCode
int retwxProcessEventGetExitCode0 = mywxProcessEvent->GetExitCode();

// Looking at class wxProgressDialog
wxProgressDialog * mywxProgressDialog;
// Looking at method wxProgressDialog::wxProgressDialog
wxString  * wxProgressDialogwxProgressDialogtitle0;
wxString  * wxProgressDialogwxProgressDialogmessage1;
int  * wxProgressDialogwxProgressDialogmaximum2;
wxWindow *  * wxProgressDialogwxProgressDialogparent3;
int  * wxProgressDialogwxProgressDialogstyle4;
wxProgressDialog * newwxProgressDialog0 = new wxProgressDialog( * wxProgressDialogwxProgressDialogtitle0,  * wxProgressDialogwxProgressDialogmessage1,  * wxProgressDialogwxProgressDialogmaximum2,  * wxProgressDialogwxProgressDialogparent3,  * wxProgressDialogwxProgressDialogstyle4);
// Looking at method wxProgressDialog::Resume
mywxProgressDialog->Resume();
// Looking at method wxProgressDialog::Update

// Looking at class wxQuantize
wxQuantize * mywxQuantize;
// Looking at method wxQuantize::wxQuantize
wxQuantize * newwxQuantize0 = new wxQuantize();
// Looking at method wxQuantize::Quantize
wxImage  * wxQuantizeQuantizesrc0;
wxImage  * wxQuantizeQuantizedest1;
wxPalette**  * wxQuantizeQuantizepPalette2;
int  * wxQuantizeQuantizedesiredNoColours3;
unsigned char**  * wxQuantizeQuantizeeightBitData4;
int  * wxQuantizeQuantizeflags5;
bool retwxQuantizeQuantize0 = mywxQuantize->Quantize( * wxQuantizeQuantizesrc0,  * wxQuantizeQuantizedest1,  * wxQuantizeQuantizepPalette2,  * wxQuantizeQuantizedesiredNoColours3,  * wxQuantizeQuantizeeightBitData4,  * wxQuantizeQuantizeflags5);
wxImage  * wxQuantizeQuantizesrc6;
wxImage  * wxQuantizeQuantizedest7;
int  * wxQuantizeQuantizedesiredNoColours8;
unsigned char**  * wxQuantizeQuantizeeightBitData9;
int  * wxQuantizeQuantizeflags10;
bool retwxQuantizeQuantize1 = mywxQuantize->Quantize( * wxQuantizeQuantizesrc6,  * wxQuantizeQuantizedest7,  * wxQuantizeQuantizedesiredNoColours8,  * wxQuantizeQuantizeeightBitData9,  * wxQuantizeQuantizeflags10);
// Looking at method wxQuantize::DoQuantize
unsigned  * wxQuantizeDoQuantizew0;
unsigned  * wxQuantizeDoQuantizeh1;
unsigned char**  * wxQuantizeDoQuantizein_rows2;
unsigned char**  * wxQuantizeDoQuantizeout_rows3;
unsigned char*  * wxQuantizeDoQuantizepalette4;
int  * wxQuantizeDoQuantizedesiredNoColours5;
mywxQuantize->DoQuantize( * wxQuantizeDoQuantizew0,  * wxQuantizeDoQuantizeh1,  * wxQuantizeDoQuantizein_rows2,  * wxQuantizeDoQuantizeout_rows3,  * wxQuantizeDoQuantizepalette4,  * wxQuantizeDoQuantizedesiredNoColours5);

// Looking at class wxQueryLayoutInfoEvent
wxQueryLayoutInfoEvent * mywxQueryLayoutInfoEvent;
// Looking at method wxQueryLayoutInfoEvent::wxQueryLayoutInfoEvent
wxWindowID  * wxQueryLayoutInfoEventwxQueryLayoutInfoEventid0;
wxQueryLayoutInfoEvent * newwxQueryLayoutInfoEvent0 = new wxQueryLayoutInfoEvent( * wxQueryLayoutInfoEventwxQueryLayoutInfoEventid0);
// Looking at method wxQueryLayoutInfoEvent::GetAlignment
mywxQueryLayoutInfoEvent->GetAlignment();
// Looking at method wxQueryLayoutInfoEvent::GetFlags
int retwxQueryLayoutInfoEventGetFlags0 = mywxQueryLayoutInfoEvent->GetFlags();
// Looking at method wxQueryLayoutInfoEvent::GetOrientation
wxLayoutOrientation retwxQueryLayoutInfoEventGetOrientation0 = mywxQueryLayoutInfoEvent->GetOrientation();
// Looking at method wxQueryLayoutInfoEvent::GetRequestedLength
int retwxQueryLayoutInfoEventGetRequestedLength0 = mywxQueryLayoutInfoEvent->GetRequestedLength();
// Looking at method wxQueryLayoutInfoEvent::GetSize
wxSize retwxQueryLayoutInfoEventGetSize0 = mywxQueryLayoutInfoEvent->GetSize();
// Looking at method wxQueryLayoutInfoEvent::SetAlignment
wxLayoutAlignment  * wxQueryLayoutInfoEventSetAlignmentalignment0;
mywxQueryLayoutInfoEvent->SetAlignment( * wxQueryLayoutInfoEventSetAlignmentalignment0);
// Looking at method wxQueryLayoutInfoEvent::SetFlags
int  * wxQueryLayoutInfoEventSetFlagsflags0;
mywxQueryLayoutInfoEvent->SetFlags( * wxQueryLayoutInfoEventSetFlagsflags0);
// Looking at method wxQueryLayoutInfoEvent::SetOrientation
wxLayoutOrientation  * wxQueryLayoutInfoEventSetOrientationorientation0;
mywxQueryLayoutInfoEvent->SetOrientation( * wxQueryLayoutInfoEventSetOrientationorientation0);
// Looking at method wxQueryLayoutInfoEvent::SetRequestedLength
int  * wxQueryLayoutInfoEventSetRequestedLengthlength0;
mywxQueryLayoutInfoEvent->SetRequestedLength( * wxQueryLayoutInfoEventSetRequestedLengthlength0);
// Looking at method wxQueryLayoutInfoEvent::SetSize
wxSize  * wxQueryLayoutInfoEventSetSizesize0;
mywxQueryLayoutInfoEvent->SetSize( * wxQueryLayoutInfoEventSetSizesize0);

// Looking at class wxRadioBox
wxRadioBox * mywxRadioBox;
// Looking at method wxRadioBox::wxRadioBox
wxRadioBox * newwxRadioBox0 = new wxRadioBox();
wxWindow*  * wxRadioBoxwxRadioBoxparent0;
wxWindowID  * wxRadioBoxwxRadioBoxid1;
wxString  * wxRadioBoxwxRadioBoxlabel2;
wxPoint  * wxRadioBoxwxRadioBoxpoint3;
wxSize  * wxRadioBoxwxRadioBoxsize4;
int  * wxRadioBoxwxRadioBoxn5;
wxString  * * wxRadioBoxwxRadioBoxchoicesptr6;
int  * wxRadioBoxwxRadioBoxmajorDimension7;
long  * wxRadioBoxwxRadioBoxstyle8;
wxValidator  * wxRadioBoxwxRadioBoxvalidator9;
wxString  * wxRadioBoxwxRadioBoxname10;
wxRadioBox * newwxRadioBox1 = new wxRadioBox( * wxRadioBoxwxRadioBoxparent0,  * wxRadioBoxwxRadioBoxid1,  * wxRadioBoxwxRadioBoxlabel2,  * wxRadioBoxwxRadioBoxpoint3,  * wxRadioBoxwxRadioBoxsize4,  * wxRadioBoxwxRadioBoxn5,  * wxRadioBoxwxRadioBoxchoicesptr6,  * wxRadioBoxwxRadioBoxmajorDimension7,  * wxRadioBoxwxRadioBoxstyle8,  * wxRadioBoxwxRadioBoxvalidator9,  * wxRadioBoxwxRadioBoxname10);
wxWindow*  * wxRadioBoxwxRadioBoxparent11;
wxWindowID  * wxRadioBoxwxRadioBoxid12;
wxString  * wxRadioBoxwxRadioBoxlabel13;
wxPoint  * wxRadioBoxwxRadioBoxpoint14;
wxSize  * wxRadioBoxwxRadioBoxsize15;
wxArrayString  * wxRadioBoxwxRadioBoxchoices16;
int  * wxRadioBoxwxRadioBoxmajorDimension17;
long  * wxRadioBoxwxRadioBoxstyle18;
wxValidator  * wxRadioBoxwxRadioBoxvalidator19;
wxString  * wxRadioBoxwxRadioBoxname20;
wxRadioBox * newwxRadioBox2 = new wxRadioBox( * wxRadioBoxwxRadioBoxparent11,  * wxRadioBoxwxRadioBoxid12,  * wxRadioBoxwxRadioBoxlabel13,  * wxRadioBoxwxRadioBoxpoint14,  * wxRadioBoxwxRadioBoxsize15,  * wxRadioBoxwxRadioBoxchoices16,  * wxRadioBoxwxRadioBoxmajorDimension17,  * wxRadioBoxwxRadioBoxstyle18,  * wxRadioBoxwxRadioBoxvalidator19,  * wxRadioBoxwxRadioBoxname20);
// Looking at method wxRadioBox::Create
wxWindow*  * wxRadioBoxCreateparent0;
wxWindowID  * wxRadioBoxCreateid1;
wxString  * wxRadioBoxCreatelabel2;
wxPoint  * wxRadioBoxCreatepoint3;
wxSize  * wxRadioBoxCreatesize4;
int  * wxRadioBoxCreaten5;
wxString  * * wxRadioBoxCreatechoicesptr6;
int  * wxRadioBoxCreatemajorDimension7;
long  * wxRadioBoxCreatestyle8;
wxValidator  * wxRadioBoxCreatevalidator9;
wxString  * wxRadioBoxCreatename10;
bool retwxRadioBoxCreate0 = mywxRadioBox->Create( * wxRadioBoxCreateparent0,  * wxRadioBoxCreateid1,  * wxRadioBoxCreatelabel2,  * wxRadioBoxCreatepoint3,  * wxRadioBoxCreatesize4,  * wxRadioBoxCreaten5,  * wxRadioBoxCreatechoicesptr6,  * wxRadioBoxCreatemajorDimension7,  * wxRadioBoxCreatestyle8,  * wxRadioBoxCreatevalidator9,  * wxRadioBoxCreatename10);
wxWindow*  * wxRadioBoxCreateparent11;
wxWindowID  * wxRadioBoxCreateid12;
wxString  * wxRadioBoxCreatelabel13;
wxPoint  * wxRadioBoxCreatepoint14;
wxSize  * wxRadioBoxCreatesize15;
wxArrayString  * wxRadioBoxCreatechoices16;
int  * wxRadioBoxCreatemajorDimension17;
long  * wxRadioBoxCreatestyle18;
wxValidator  * wxRadioBoxCreatevalidator19;
wxString  * wxRadioBoxCreatename20;
bool retwxRadioBoxCreate1 = mywxRadioBox->Create( * wxRadioBoxCreateparent11,  * wxRadioBoxCreateid12,  * wxRadioBoxCreatelabel13,  * wxRadioBoxCreatepoint14,  * wxRadioBoxCreatesize15,  * wxRadioBoxCreatechoices16,  * wxRadioBoxCreatemajorDimension17,  * wxRadioBoxCreatestyle18,  * wxRadioBoxCreatevalidator19,  * wxRadioBoxCreatename20);
// Looking at method wxRadioBox::Enable
bool  * wxRadioBoxEnableenable0;
mywxRadioBox->Enable( * wxRadioBoxEnableenable0);
int  * wxRadioBoxEnablen1;
bool  * wxRadioBoxEnableenable2;
mywxRadioBox->Enable( * wxRadioBoxEnablen1,  * wxRadioBoxEnableenable2);
// Looking at method wxRadioBox::FindString
wxString  * wxRadioBoxFindStringstring0;
int retwxRadioBoxFindString0 = mywxRadioBox->FindString( * wxRadioBoxFindStringstring0);
// Looking at method wxRadioBox::GetCount
int retwxRadioBoxGetCount0 = mywxRadioBox->GetCount();
// Looking at method wxRadioBox::GetLabel
wxString retwxRadioBoxGetLabel0 = mywxRadioBox->GetLabel();
// Looking at method wxRadioBox::GetSelection
int retwxRadioBoxGetSelection0 = mywxRadioBox->GetSelection();
// Looking at method wxRadioBox::GetStringSelection
wxString retwxRadioBoxGetStringSelection0 = mywxRadioBox->GetStringSelection();
// Looking at method wxRadioBox::GetString
int  * wxRadioBoxGetStringn0;
wxString retwxRadioBoxGetString0 = mywxRadioBox->GetString( * wxRadioBoxGetStringn0);
// Looking at method wxRadioBox::SetLabel
wxString  * wxRadioBoxSetLabellabel0;
mywxRadioBox->SetLabel( * wxRadioBoxSetLabellabel0);
// Looking at method wxRadioBox::SetSelection
int  * wxRadioBoxSetSelectionn0;
mywxRadioBox->SetSelection( * wxRadioBoxSetSelectionn0);
// Looking at method wxRadioBox::SetStringSelection
wxString  * wxRadioBoxSetStringSelectionstring0;
mywxRadioBox->SetStringSelection( * wxRadioBoxSetStringSelectionstring0);
// Looking at method wxRadioBox::Show
bool  * wxRadioBoxShowshow0;
mywxRadioBox->Show( * wxRadioBoxShowshow0);
int  * wxRadioBoxShowitem1;
bool  * wxRadioBoxShowshow2;
mywxRadioBox->Show( * wxRadioBoxShowitem1,  * wxRadioBoxShowshow2);

// Looking at class wxRadioButton
wxRadioButton * mywxRadioButton;
// Looking at method wxRadioButton::wxRadioButton
wxRadioButton * newwxRadioButton0 = new wxRadioButton();
wxWindow*  * wxRadioButtonwxRadioButtonparent0;
wxWindowID  * wxRadioButtonwxRadioButtonid1;
wxString  * wxRadioButtonwxRadioButtonlabel2;
wxPoint  * wxRadioButtonwxRadioButtonpos3;
wxSize  * wxRadioButtonwxRadioButtonsize4;
long  * wxRadioButtonwxRadioButtonstyle5;
wxValidator  * wxRadioButtonwxRadioButtonvalidator6;
wxString  * wxRadioButtonwxRadioButtonname7;
wxRadioButton * newwxRadioButton1 = new wxRadioButton( * wxRadioButtonwxRadioButtonparent0,  * wxRadioButtonwxRadioButtonid1,  * wxRadioButtonwxRadioButtonlabel2,  * wxRadioButtonwxRadioButtonpos3,  * wxRadioButtonwxRadioButtonsize4,  * wxRadioButtonwxRadioButtonstyle5,  * wxRadioButtonwxRadioButtonvalidator6,  * wxRadioButtonwxRadioButtonname7);
// Looking at method wxRadioButton::Create
wxWindow*  * wxRadioButtonCreateparent0;
wxWindowID  * wxRadioButtonCreateid1;
wxString  * wxRadioButtonCreatelabel2;
wxPoint  * wxRadioButtonCreatepos3;
wxSize  * wxRadioButtonCreatesize4;
long  * wxRadioButtonCreatestyle5;
wxValidator  * wxRadioButtonCreatevalidator6;
wxString  * wxRadioButtonCreatename7;
bool retwxRadioButtonCreate0 = mywxRadioButton->Create( * wxRadioButtonCreateparent0,  * wxRadioButtonCreateid1,  * wxRadioButtonCreatelabel2,  * wxRadioButtonCreatepos3,  * wxRadioButtonCreatesize4,  * wxRadioButtonCreatestyle5,  * wxRadioButtonCreatevalidator6,  * wxRadioButtonCreatename7);
// Looking at method wxRadioButton::GetValue
bool retwxRadioButtonGetValue0 = mywxRadioButton->GetValue();
// Looking at method wxRadioButton::SetValue
bool  * wxRadioButtonSetValuevalue0;
mywxRadioButton->SetValue( * wxRadioButtonSetValuevalue0);

// Looking at class wxRealPoint
wxRealPoint * mywxRealPoint;
// Looking at method wxRealPoint::wxRealPoint
wxRealPoint * newwxRealPoint0 = new wxRealPoint();
double  * wxRealPointwxRealPointx0;
double  * wxRealPointwxRealPointy1;
wxRealPoint * newwxRealPoint1 = new wxRealPoint( * wxRealPointwxRealPointx0,  * wxRealPointwxRealPointy1);

// Looking at class wxRect
wxRect * mywxRect;
// Looking at method wxRect::wxRect
wxRect * newwxRect0 = new wxRect();
int  * wxRectwxRectx0;
int  * wxRectwxRecty1;
int  * wxRectwxRectwidth2;
int  * wxRectwxRectheight3;
wxRect * newwxRect1 = new wxRect( * wxRectwxRectx0,  * wxRectwxRecty1,  * wxRectwxRectwidth2,  * wxRectwxRectheight3);
wxPoint  * wxRectwxRecttopLeft4;
wxPoint  * wxRectwxRectbottomRight5;
wxRect * newwxRect2 = new wxRect( * wxRectwxRecttopLeft4,  * wxRectwxRectbottomRight5);
wxPoint  * wxRectwxRectpos6;
wxSize  * wxRectwxRectsize7;
wxRect * newwxRect3 = new wxRect( * wxRectwxRectpos6,  * wxRectwxRectsize7);
wxSize  * wxRectwxRectsize8;
wxRect * newwxRect4 = new wxRect( * wxRectwxRectsize8);
// Looking at method wxRect::x
// Looking at method wxRect::y
// Looking at method wxRect::width
// Looking at method wxRect::height
// Looking at method wxRect::Deflate
wxCoord  * wxRectDeflatedx0;
wxCoord  * wxRectDeflatedy1;
mywxRect->Deflate( * wxRectDeflatedx0,  * wxRectDeflatedy1);
wxCoord  * wxRectDeflatediff2;
mywxRect->Deflate( * wxRectDeflatediff2);
wxCoord  * wxRectDeflatedx3;
wxCoord  * wxRectDeflatedy4;
wxRect retwxRectDeflate2 = mywxRect->Deflate( * wxRectDeflatedx3,  * wxRectDeflatedy4);
// Looking at method wxRect::GetBottom
int retwxRectGetBottom0 = mywxRect->GetBottom();
// Looking at method wxRect::GetHeight
int retwxRectGetHeight0 = mywxRect->GetHeight();
// Looking at method wxRect::GetLeft
int retwxRectGetLeft0 = mywxRect->GetLeft();
// Looking at method wxRect::GetPosition
wxPoint retwxRectGetPosition0 = mywxRect->GetPosition();
// Looking at method wxRect::GetTopLeft
wxPoint retwxRectGetTopLeft0 = mywxRect->GetTopLeft();
// Looking at method wxRect::GetBottomRight
wxPoint retwxRectGetBottomRight0 = mywxRect->GetBottomRight();
// Looking at method wxRect::GetRight
int retwxRectGetRight0 = mywxRect->GetRight();
// Looking at method wxRect::GetSize
wxSize retwxRectGetSize0 = mywxRect->GetSize();
// Looking at method wxRect::GetTop
int retwxRectGetTop0 = mywxRect->GetTop();
// Looking at method wxRect::GetWidth
int retwxRectGetWidth0 = mywxRect->GetWidth();
// Looking at method wxRect::GetX
int retwxRectGetX0 = mywxRect->GetX();
// Looking at method wxRect::GetY
int retwxRectGetY0 = mywxRect->GetY();
// Looking at method wxRect::Inflate
wxCoord  * wxRectInflatedx0;
wxCoord  * wxRectInflatedy1;
mywxRect->Inflate( * wxRectInflatedx0,  * wxRectInflatedy1);
wxCoord  * wxRectInflatediff2;
mywxRect->Inflate( * wxRectInflatediff2);
wxCoord  * wxRectInflatedx3;
wxCoord  * wxRectInflatedy4;
wxRect retwxRectInflate2 = mywxRect->Inflate( * wxRectInflatedx3,  * wxRectInflatedy4);
// Looking at method wxRect::Inside
int  * wxRectInsidex0;
int  * wxRectInsidey1;
bool retwxRectInside0 = mywxRect->Inside( * wxRectInsidex0,  * wxRectInsidey1);
wxPoint  * wxRectInsidept2;
bool retwxRectInside1 = mywxRect->Inside( * wxRectInsidept2);
// Looking at method wxRect::Intersects
wxRect  * wxRectIntersectsrect0;
bool retwxRectIntersects0 = mywxRect->Intersects( * wxRectIntersectsrect0);
// Looking at method wxRect::Offset
wxCoord  * wxRectOffsetdx0;
wxCoord  * wxRectOffsetdy1;
mywxRect->Offset( * wxRectOffsetdx0,  * wxRectOffsetdy1);
wxPoint  * wxRectOffsetpt2;
mywxRect->Offset( * wxRectOffsetpt2);
// Looking at method wxRect::SetHeight
int  * wxRectSetHeightheight0;
mywxRect->SetHeight( * wxRectSetHeightheight0);
// Looking at method wxRect::SetWidth
int  * wxRectSetWidthwidth0;
mywxRect->SetWidth( * wxRectSetWidthwidth0);
// Looking at method wxRect::SetX
int  * wxRectSetXx0;
mywxRect->SetX( * wxRectSetXx0);
// Looking at method wxRect::SetY
int  * wxRectSetYy0;
mywxRect->SetY( * wxRectSetYy0);
// Looking at method wxRect::Union
wxRect  * wxRectUnionrect0;
wxRect retwxRectUnion0 = mywxRect->Union( * wxRectUnionrect0);
wxRect  * wxRectUnionrect1;
wxRect retwxRectUnion1 = mywxRect->Union( * wxRectUnionrect1);

// Looking at class wxRecursionGuard
wxRecursionGuard * mywxRecursionGuard;
// Looking at method wxRecursionGuard::wxRecursionGuard
wxRecursionGuardFlag  * wxRecursionGuardwxRecursionGuardflag0;
wxRecursionGuard * newwxRecursionGuard0 = new wxRecursionGuard( * wxRecursionGuardwxRecursionGuardflag0);
// Looking at method wxRecursionGuard::IsInside
bool retwxRecursionGuardIsInside0 = mywxRecursionGuard->IsInside();

// Looking at class wxRecursionGuardFlag
wxRecursionGuardFlag * mywxRecursionGuardFlag;

// Looking at class wxRegEx
wxRegEx * mywxRegEx;
// Looking at method wxRegEx::wxRegEx
wxRegEx * newwxRegEx0 = new wxRegEx();
wxString  * wxRegExwxRegExexpr0;
int  * wxRegExwxRegExflags1;
wxRegEx * newwxRegEx1 = new wxRegEx( * wxRegExwxRegExexpr0,  * wxRegExwxRegExflags1);
// Looking at method wxRegEx::Compile
wxString  * wxRegExCompilepattern0;
int  * wxRegExCompileflags1;
bool retwxRegExCompile0 = mywxRegEx->Compile( * wxRegExCompilepattern0,  * wxRegExCompileflags1);
// Looking at method wxRegEx::IsValid
bool retwxRegExIsValid0 = mywxRegEx->IsValid();
// Looking at method wxRegEx::GetMatch
size_t*  * wxRegExGetMatchstart0;
size_t*  * wxRegExGetMatchlen1;
size_t  * wxRegExGetMatchindex2;
bool retwxRegExGetMatch0 = mywxRegEx->GetMatch( * wxRegExGetMatchstart0,  * wxRegExGetMatchlen1,  * wxRegExGetMatchindex2);
wxString  * wxRegExGetMatchtext3;
size_t  * wxRegExGetMatchindex4;
wxString retwxRegExGetMatch1 = mywxRegEx->GetMatch( * wxRegExGetMatchtext3,  * wxRegExGetMatchindex4);
// Looking at method wxRegEx::GetMatchCount
size_t retwxRegExGetMatchCount0 = mywxRegEx->GetMatchCount();
// Looking at method wxRegEx::Matches
wxChar*  * wxRegExMatchestext0;
int  * wxRegExMatchesflags1;
bool retwxRegExMatches0 = mywxRegEx->Matches( * wxRegExMatchestext0,  * wxRegExMatchesflags1);
// Looking at method wxRegEx::Replace
wxString*  * wxRegExReplacetext0;
wxString  * wxRegExReplacereplacement1;
size_t  * wxRegExReplacemaxMatches2;
int retwxRegExReplace0 = mywxRegEx->Replace( * wxRegExReplacetext0,  * wxRegExReplacereplacement1,  * wxRegExReplacemaxMatches2);
// Looking at method wxRegEx::ReplaceAll
wxString*  * wxRegExReplaceAlltext0;
wxString  * wxRegExReplaceAllreplacement1;
int retwxRegExReplaceAll0 = mywxRegEx->ReplaceAll( * wxRegExReplaceAlltext0,  * wxRegExReplaceAllreplacement1);
// Looking at method wxRegEx::ReplaceFirst
wxString*  * wxRegExReplaceFirsttext0;
wxString  * wxRegExReplaceFirstreplacement1;
int retwxRegExReplaceFirst0 = mywxRegEx->ReplaceFirst( * wxRegExReplaceFirsttext0,  * wxRegExReplaceFirstreplacement1);

// Looking at class wxRegion
wxRegion * mywxRegion;
// Looking at method wxRegion::wxRegion
wxRegion * newwxRegion0 = new wxRegion();
wxCoord  * wxRegionwxRegionx0;
wxCoord  * wxRegionwxRegiony1;
wxCoord  * wxRegionwxRegionwidth2;
wxCoord  * wxRegionwxRegionheight3;
wxRegion * newwxRegion1 = new wxRegion( * wxRegionwxRegionx0,  * wxRegionwxRegiony1,  * wxRegionwxRegionwidth2,  * wxRegionwxRegionheight3);
wxPoint  * wxRegionwxRegiontopLeft4;
wxPoint  * wxRegionwxRegionbottomRight5;
wxRegion * newwxRegion2 = new wxRegion( * wxRegionwxRegiontopLeft4,  * wxRegionwxRegionbottomRight5);
wxRect  * wxRegionwxRegionrect6;
wxRegion * newwxRegion3 = new wxRegion( * wxRegionwxRegionrect6);
wxRegion  * wxRegionwxRegionregion7;
wxRegion * newwxRegion4 = new wxRegion( * wxRegionwxRegionregion7);
size_t  * wxRegionwxRegionn8;
wxPoint * * wxRegionwxRegionpoints9;
int  * wxRegionwxRegionfillStyle10;
wxRegion * newwxRegion5 = new wxRegion( * wxRegionwxRegionn8,  * wxRegionwxRegionpoints9,  * wxRegionwxRegionfillStyle10);
wxBitmap  * wxRegionwxRegionbmp11;
wxRegion * newwxRegion6 = new wxRegion( * wxRegionwxRegionbmp11);
wxBitmap  * wxRegionwxRegionbmp12;
wxColour  * wxRegionwxRegiontransColour13;
int  * wxRegionwxRegiontolerance14;
wxRegion * newwxRegion7 = new wxRegion( * wxRegionwxRegionbmp12,  * wxRegionwxRegiontransColour13,  * wxRegionwxRegiontolerance14);
// Looking at method wxRegion::Clear
mywxRegion->Clear();
// Looking at method wxRegion::Contains
long  * wxRegionContainsx0;
long  * wxRegionContainsy1;
wxRegionContain retwxRegionContains0 = mywxRegion->Contains( * wxRegionContainsx0,  * wxRegionContainsy1);
wxPoint  * wxRegionContainspt2;
wxRegionContain retwxRegionContains1 = mywxRegion->Contains( * wxRegionContainspt2);
long  * wxRegionContainsx3;
long  * wxRegionContainsy4;
long  * wxRegionContainswidth5;
long  * wxRegionContainsheight6;
wxRegionContain retwxRegionContains2 = mywxRegion->Contains( * wxRegionContainsx3,  * wxRegionContainsy4,  * wxRegionContainswidth5,  * wxRegionContainsheight6);
wxRect  * wxRegionContainsrect7;
wxRegionContain retwxRegionContains3 = mywxRegion->Contains( * wxRegionContainsrect7);
// Looking at method wxRegion::ConvertToBitmap
wxBitmap retwxRegionConvertToBitmap0 = mywxRegion->ConvertToBitmap();
// Looking at method wxRegion::GetBox
wxCoord  * wxRegionGetBoxx0;
wxCoord  * wxRegionGetBoxy1;
wxCoord  * wxRegionGetBoxwidth2;
wxCoord  * wxRegionGetBoxheight3;
mywxRegion->GetBox( * wxRegionGetBoxx0,  * wxRegionGetBoxy1,  * wxRegionGetBoxwidth2,  * wxRegionGetBoxheight3);
wxRect retwxRegionGetBox1 = mywxRegion->GetBox();
// Looking at method wxRegion::Intersect
wxCoord  * wxRegionIntersectx0;
wxCoord  * wxRegionIntersecty1;
wxCoord  * wxRegionIntersectwidth2;
wxCoord  * wxRegionIntersectheight3;
bool retwxRegionIntersect0 = mywxRegion->Intersect( * wxRegionIntersectx0,  * wxRegionIntersecty1,  * wxRegionIntersectwidth2,  * wxRegionIntersectheight3);
wxRect  * wxRegionIntersectrect4;
bool retwxRegionIntersect1 = mywxRegion->Intersect( * wxRegionIntersectrect4);
wxRegion  * wxRegionIntersectregion5;
bool retwxRegionIntersect2 = mywxRegion->Intersect( * wxRegionIntersectregion5);
// Looking at method wxRegion::IsEmpty
bool retwxRegionIsEmpty0 = mywxRegion->IsEmpty();
// Looking at method wxRegion::Subtract
wxRect  * wxRegionSubtractrect0;
bool retwxRegionSubtract0 = mywxRegion->Subtract( * wxRegionSubtractrect0);
wxRegion  * wxRegionSubtractregion1;
bool retwxRegionSubtract1 = mywxRegion->Subtract( * wxRegionSubtractregion1);
// Looking at method wxRegion::Offset
wxCoord  * wxRegionOffsetx0;
wxCoord  * wxRegionOffsety1;
bool retwxRegionOffset0 = mywxRegion->Offset( * wxRegionOffsetx0,  * wxRegionOffsety1);
// Looking at method wxRegion::Union
wxCoord  * wxRegionUnionx0;
wxCoord  * wxRegionUniony1;
wxCoord  * wxRegionUnionwidth2;
wxCoord  * wxRegionUnionheight3;
bool retwxRegionUnion0 = mywxRegion->Union( * wxRegionUnionx0,  * wxRegionUniony1,  * wxRegionUnionwidth2,  * wxRegionUnionheight3);
wxRect  * wxRegionUnionrect4;
bool retwxRegionUnion1 = mywxRegion->Union( * wxRegionUnionrect4);
wxRegion  * wxRegionUnionregion5;
bool retwxRegionUnion2 = mywxRegion->Union( * wxRegionUnionregion5);
wxBitmap  * wxRegionUnionbmp6;
bool retwxRegionUnion3 = mywxRegion->Union( * wxRegionUnionbmp6);
wxBitmap  * wxRegionUnionbmp7;
wxColour  * wxRegionUniontransColour8;
int  * wxRegionUniontolerance9;
bool retwxRegionUnion4 = mywxRegion->Union( * wxRegionUnionbmp7,  * wxRegionUniontransColour8,  * wxRegionUniontolerance9);
// Looking at method wxRegion::Xor
wxCoord  * wxRegionXorx0;
wxCoord  * wxRegionXory1;
wxCoord  * wxRegionXorwidth2;
wxCoord  * wxRegionXorheight3;
bool retwxRegionXor0 = mywxRegion->Xor( * wxRegionXorx0,  * wxRegionXory1,  * wxRegionXorwidth2,  * wxRegionXorheight3);
wxRect  * wxRegionXorrect4;
bool retwxRegionXor1 = mywxRegion->Xor( * wxRegionXorrect4);
wxRegion  * wxRegionXorregion5;
bool retwxRegionXor2 = mywxRegion->Xor( * wxRegionXorregion5);

// Looking at class wxRegionIterator
wxRegionIterator * mywxRegionIterator;
// Looking at method wxRegionIterator::wxRegionIterator
wxRegionIterator * newwxRegionIterator0 = new wxRegionIterator();
wxRegion  * wxRegionIteratorwxRegionIteratorregion0;
wxRegionIterator * newwxRegionIterator1 = new wxRegionIterator( * wxRegionIteratorwxRegionIteratorregion0);
// Looking at method wxRegionIterator::GetX
wxCoord retwxRegionIteratorGetX0 = mywxRegionIterator->GetX();
// Looking at method wxRegionIterator::GetY
wxCoord retwxRegionIteratorGetY0 = mywxRegionIterator->GetY();
// Looking at method wxRegionIterator::GetW
wxCoord retwxRegionIteratorGetW0 = mywxRegionIterator->GetW();
// Looking at method wxRegionIterator::GetHeight
wxCoord retwxRegionIteratorGetHeight0 = mywxRegionIterator->GetHeight();
// Looking at method wxRegionIterator::GetH
wxCoord retwxRegionIteratorGetH0 = mywxRegionIterator->GetH();
// Looking at method wxRegionIterator::GetRect
wxRect retwxRegionIteratorGetRect0 = mywxRegionIterator->GetRect();
// Looking at method wxRegionIterator::GetWidth
wxCoord retwxRegionIteratorGetWidth0 = mywxRegionIterator->GetWidth();
// Looking at method wxRegionIterator::HaveRects
bool retwxRegionIteratorHaveRects0 = mywxRegionIterator->HaveRects();
// Looking at method wxRegionIterator::Reset
mywxRegionIterator->Reset();
wxRegion  * wxRegionIteratorResetregion0;
mywxRegionIterator->Reset( * wxRegionIteratorResetregion0);

// Looking at class wxRendererVersion
wxRendererVersion * mywxRendererVersion;
// Looking at method wxRendererVersion::IsCompatible
wxRendererVersion  * wxRendererVersionIsCompatiblever0;
static bool retwxRendererVersionIsCompatible0 = mywxRendererVersion->IsCompatible( * wxRendererVersionIsCompatiblever0);
// Looking at method wxRendererVersion::version
// Looking at method wxRendererVersion::age

// Looking at class wxSashEvent
wxSashEvent * mywxSashEvent;
// Looking at method wxSashEvent::wxSashEvent
int  * wxSashEventwxSashEventid0;
wxSashEdgePosition  * wxSashEventwxSashEventedge1;
wxSashEvent * newwxSashEvent0 = new wxSashEvent( * wxSashEventwxSashEventid0,  * wxSashEventwxSashEventedge1);
// Looking at method wxSashEvent::GetEdge
wxSashEdgePosition retwxSashEventGetEdge0 = mywxSashEvent->GetEdge();
// Looking at method wxSashEvent::GetDragRect
wxRect retwxSashEventGetDragRect0 = mywxSashEvent->GetDragRect();
// Looking at method wxSashEvent::GetDragStatus
wxSashDragStatus retwxSashEventGetDragStatus0 = mywxSashEvent->GetDragStatus();

// Looking at class wxSashLayoutWindow
wxSashLayoutWindow * mywxSashLayoutWindow;
// Looking at method wxSashLayoutWindow::wxSashLayoutWindow
wxSashLayoutWindow * newwxSashLayoutWindow0 = new wxSashLayoutWindow();
wxSashLayoutWindow*  * wxSashLayoutWindowwxSashLayoutWindowparent0;
wxWindowID  * wxSashLayoutWindowwxSashLayoutWindowid1;
wxPoint  * wxSashLayoutWindowwxSashLayoutWindowpos2;
wxSize  * wxSashLayoutWindowwxSashLayoutWindowsize3;
long  * wxSashLayoutWindowwxSashLayoutWindowstyle4;
wxString  * wxSashLayoutWindowwxSashLayoutWindowname5;
wxSashLayoutWindow * newwxSashLayoutWindow1 = new wxSashLayoutWindow( * wxSashLayoutWindowwxSashLayoutWindowparent0,  * wxSashLayoutWindowwxSashLayoutWindowid1,  * wxSashLayoutWindowwxSashLayoutWindowpos2,  * wxSashLayoutWindowwxSashLayoutWindowsize3,  * wxSashLayoutWindowwxSashLayoutWindowstyle4,  * wxSashLayoutWindowwxSashLayoutWindowname5);
// Looking at method wxSashLayoutWindow::Create
wxSashLayoutWindow*  * wxSashLayoutWindowCreateparent0;
wxWindowID  * wxSashLayoutWindowCreateid1;
wxPoint  * wxSashLayoutWindowCreatepos2;
wxSize  * wxSashLayoutWindowCreatesize3;
long  * wxSashLayoutWindowCreatestyle4;
wxString  * wxSashLayoutWindowCreatename5;
bool retwxSashLayoutWindowCreate0 = mywxSashLayoutWindow->Create( * wxSashLayoutWindowCreateparent0,  * wxSashLayoutWindowCreateid1,  * wxSashLayoutWindowCreatepos2,  * wxSashLayoutWindowCreatesize3,  * wxSashLayoutWindowCreatestyle4,  * wxSashLayoutWindowCreatename5);
// Looking at method wxSashLayoutWindow::GetAlignment
wxLayoutAlignment retwxSashLayoutWindowGetAlignment0 = mywxSashLayoutWindow->GetAlignment();
// Looking at method wxSashLayoutWindow::GetOrientation
wxLayoutOrientation retwxSashLayoutWindowGetOrientation0 = mywxSashLayoutWindow->GetOrientation();
// Looking at method wxSashLayoutWindow::OnCalculateLayout
wxCalculateLayoutEvent  * wxSashLayoutWindowOnCalculateLayoutevent0;
mywxSashLayoutWindow->OnCalculateLayout( * wxSashLayoutWindowOnCalculateLayoutevent0);
// Looking at method wxSashLayoutWindow::OnQueryLayoutInfo
wxQueryLayoutInfoEvent  * wxSashLayoutWindowOnQueryLayoutInfoevent0;
mywxSashLayoutWindow->OnQueryLayoutInfo( * wxSashLayoutWindowOnQueryLayoutInfoevent0);
// Looking at method wxSashLayoutWindow::SetAlignment
wxLayoutAlignment  * wxSashLayoutWindowSetAlignmentalignment0;
mywxSashLayoutWindow->SetAlignment( * wxSashLayoutWindowSetAlignmentalignment0);
// Looking at method wxSashLayoutWindow::SetDefaultSize
wxSize  * wxSashLayoutWindowSetDefaultSizesize0;
mywxSashLayoutWindow->SetDefaultSize( * wxSashLayoutWindowSetDefaultSizesize0);
// Looking at method wxSashLayoutWindow::SetOrientation
wxLayoutOrientation  * wxSashLayoutWindowSetOrientationorientation0;
mywxSashLayoutWindow->SetOrientation( * wxSashLayoutWindowSetOrientationorientation0);

// Looking at class wxSashWindow
wxSashWindow * mywxSashWindow;
// Looking at method wxSashWindow::wxSashWindow
wxSashWindow * newwxSashWindow0 = new wxSashWindow();
wxWindow*  * wxSashWindowwxSashWindowparent0;
wxWindowID  * wxSashWindowwxSashWindowid1;
wxPoint  * wxSashWindowwxSashWindowpos2;
wxSize  * wxSashWindowwxSashWindowsize3;
long  * wxSashWindowwxSashWindowstyle4;
wxString  * wxSashWindowwxSashWindowname5;
wxSashWindow * newwxSashWindow1 = new wxSashWindow( * wxSashWindowwxSashWindowparent0,  * wxSashWindowwxSashWindowid1,  * wxSashWindowwxSashWindowpos2,  * wxSashWindowwxSashWindowsize3,  * wxSashWindowwxSashWindowstyle4,  * wxSashWindowwxSashWindowname5);
// Looking at method wxSashWindow::GetSashVisible
wxSashEdgePosition  * wxSashWindowGetSashVisibleedge0;
bool retwxSashWindowGetSashVisible0 = mywxSashWindow->GetSashVisible( * wxSashWindowGetSashVisibleedge0);
// Looking at method wxSashWindow::GetMaximumSizeX
int retwxSashWindowGetMaximumSizeX0 = mywxSashWindow->GetMaximumSizeX();
// Looking at method wxSashWindow::GetMaximumSizeY
int retwxSashWindowGetMaximumSizeY0 = mywxSashWindow->GetMaximumSizeY();
// Looking at method wxSashWindow::GetMinimumSizeX
int retwxSashWindowGetMinimumSizeX0 = mywxSashWindow->GetMinimumSizeX();
// Looking at method wxSashWindow::GetMinimumSizeY
int retwxSashWindowGetMinimumSizeY0 = mywxSashWindow->GetMinimumSizeY();
// Looking at method wxSashWindow::HasBorder
wxSashEdgePosition  * wxSashWindowHasBorderedge0;
bool retwxSashWindowHasBorder0 = mywxSashWindow->HasBorder( * wxSashWindowHasBorderedge0);
// Looking at method wxSashWindow::SetMaximumSizeX
int  * wxSashWindowSetMaximumSizeXmin0;
mywxSashWindow->SetMaximumSizeX( * wxSashWindowSetMaximumSizeXmin0);
// Looking at method wxSashWindow::SetMaximumSizeY
int  * wxSashWindowSetMaximumSizeYmin0;
mywxSashWindow->SetMaximumSizeY( * wxSashWindowSetMaximumSizeYmin0);
// Looking at method wxSashWindow::SetMinimumSizeX
int  * wxSashWindowSetMinimumSizeXmin0;
mywxSashWindow->SetMinimumSizeX( * wxSashWindowSetMinimumSizeXmin0);
// Looking at method wxSashWindow::SetMinimumSizeY
int  * wxSashWindowSetMinimumSizeYmin0;
mywxSashWindow->SetMinimumSizeY( * wxSashWindowSetMinimumSizeYmin0);
// Looking at method wxSashWindow::SetSashVisible
wxSashEdgePosition  * wxSashWindowSetSashVisibleedge0;
bool  * wxSashWindowSetSashVisiblevisible1;
mywxSashWindow->SetSashVisible( * wxSashWindowSetSashVisibleedge0,  * wxSashWindowSetSashVisiblevisible1);
// Looking at method wxSashWindow::SetSashBorder
wxSashEdgePosition  * wxSashWindowSetSashBorderedge0;
bool  * wxSashWindowSetSashBorderhasBorder1;
mywxSashWindow->SetSashBorder( * wxSashWindowSetSashBorderedge0,  * wxSashWindowSetSashBorderhasBorder1);

// Looking at class wxScreenDC
wxScreenDC * mywxScreenDC;
// Looking at method wxScreenDC::wxScreenDC
wxScreenDC * newwxScreenDC0 = new wxScreenDC();
// Looking at method wxScreenDC::StartDrawingOnTop
wxWindow*  * wxScreenDCStartDrawingOnTopwindow0;
bool retwxScreenDCStartDrawingOnTop0 = mywxScreenDC->StartDrawingOnTop( * wxScreenDCStartDrawingOnTopwindow0);
wxRect*  * wxScreenDCStartDrawingOnToprect1;
bool retwxScreenDCStartDrawingOnTop1 = mywxScreenDC->StartDrawingOnTop( * wxScreenDCStartDrawingOnToprect1);
// Looking at method wxScreenDC::EndDrawingOnTop
bool retwxScreenDCEndDrawingOnTop0 = mywxScreenDC->EndDrawingOnTop();

// Looking at class wxScrollBar
wxScrollBar * mywxScrollBar;

// Looking at class wxScrollEvent
wxScrollEvent * mywxScrollEvent;
// Looking at method wxScrollEvent::wxScrollEvent
WXTYPE  * wxScrollEventwxScrollEventcommandType0;
int  * wxScrollEventwxScrollEventid1;
int  * wxScrollEventwxScrollEventpos2;
int  * wxScrollEventwxScrollEventorientation3;
wxScrollEvent * newwxScrollEvent0 = new wxScrollEvent( * wxScrollEventwxScrollEventcommandType0,  * wxScrollEventwxScrollEventid1,  * wxScrollEventwxScrollEventpos2,  * wxScrollEventwxScrollEventorientation3);
// Looking at method wxScrollEvent::GetOrientation
int retwxScrollEventGetOrientation0 = mywxScrollEvent->GetOrientation();
// Looking at method wxScrollEvent::GetPosition
int retwxScrollEventGetPosition0 = mywxScrollEvent->GetPosition();

// Looking at class wxScrollWinEvent
wxScrollWinEvent * mywxScrollWinEvent;
// Looking at method wxScrollWinEvent::wxScrollWinEvent
WXTYPE  * wxScrollWinEventwxScrollWinEventcommandType0;
int  * wxScrollWinEventwxScrollWinEventpos1;
int  * wxScrollWinEventwxScrollWinEventorientation2;
wxScrollWinEvent * newwxScrollWinEvent0 = new wxScrollWinEvent( * wxScrollWinEventwxScrollWinEventcommandType0,  * wxScrollWinEventwxScrollWinEventpos1,  * wxScrollWinEventwxScrollWinEventorientation2);
// Looking at method wxScrollWinEvent::GetOrientation
int retwxScrollWinEventGetOrientation0 = mywxScrollWinEvent->GetOrientation();
// Looking at method wxScrollWinEvent::GetPosition
int retwxScrollWinEventGetPosition0 = mywxScrollWinEvent->GetPosition();

// Looking at class wxScrolledWindow
wxScrolledWindow * mywxScrolledWindow;
// Looking at method wxScrolledWindow::wxScrolledWindow
wxScrolledWindow * newwxScrolledWindow0 = new wxScrolledWindow();
wxWindow*  * wxScrolledWindowwxScrolledWindowparent0;
wxWindowID  * wxScrolledWindowwxScrolledWindowid1;
wxPoint  * wxScrolledWindowwxScrolledWindowpos2;
wxSize  * wxScrolledWindowwxScrolledWindowsize3;
long  * wxScrolledWindowwxScrolledWindowstyle4;
wxString  * wxScrolledWindowwxScrolledWindowname5;
wxScrolledWindow * newwxScrolledWindow1 = new wxScrolledWindow( * wxScrolledWindowwxScrolledWindowparent0,  * wxScrolledWindowwxScrolledWindowid1,  * wxScrolledWindowwxScrolledWindowpos2,  * wxScrolledWindowwxScrolledWindowsize3,  * wxScrolledWindowwxScrolledWindowstyle4,  * wxScrolledWindowwxScrolledWindowname5);
// Looking at method wxScrolledWindow::CalcScrolledPosition
int  * wxScrolledWindowCalcScrolledPositionx0;
int  * wxScrolledWindowCalcScrolledPositiony1;
int * * wxScrolledWindowCalcScrolledPositionxx2;
int * * wxScrolledWindowCalcScrolledPositionyy3;
mywxScrolledWindow->CalcScrolledPosition( * wxScrolledWindowCalcScrolledPositionx0,  * wxScrolledWindowCalcScrolledPositiony1,  * wxScrolledWindowCalcScrolledPositionxx2,  * wxScrolledWindowCalcScrolledPositionyy3);
// Looking at method wxScrolledWindow::CalcUnscrolledPosition
int  * wxScrolledWindowCalcUnscrolledPositionx0;
int  * wxScrolledWindowCalcUnscrolledPositiony1;
int * * wxScrolledWindowCalcUnscrolledPositionxx2;
int * * wxScrolledWindowCalcUnscrolledPositionyy3;
mywxScrolledWindow->CalcUnscrolledPosition( * wxScrolledWindowCalcUnscrolledPositionx0,  * wxScrolledWindowCalcUnscrolledPositiony1,  * wxScrolledWindowCalcUnscrolledPositionxx2,  * wxScrolledWindowCalcUnscrolledPositionyy3);
// Looking at method wxScrolledWindow::Create
wxWindow*  * wxScrolledWindowCreateparent0;
wxWindowID  * wxScrolledWindowCreateid1;
wxPoint  * wxScrolledWindowCreatepos2;
wxSize  * wxScrolledWindowCreatesize3;
long  * wxScrolledWindowCreatestyle4;
wxString  * wxScrolledWindowCreatename5;
bool retwxScrolledWindowCreate0 = mywxScrolledWindow->Create( * wxScrolledWindowCreateparent0,  * wxScrolledWindowCreateid1,  * wxScrolledWindowCreatepos2,  * wxScrolledWindowCreatesize3,  * wxScrolledWindowCreatestyle4,  * wxScrolledWindowCreatename5);
// Looking at method wxScrolledWindow::EnableScrolling
bool  * wxScrolledWindowEnableScrollingxScrolling0;
bool  * wxScrolledWindowEnableScrollingyScrolling1;
mywxScrolledWindow->EnableScrolling( * wxScrolledWindowEnableScrollingxScrolling0,  * wxScrolledWindowEnableScrollingyScrolling1);
// Looking at method wxScrolledWindow::GetScrollPixelsPerUnit
int*  * wxScrolledWindowGetScrollPixelsPerUnitxUnit0;
int*  * wxScrolledWindowGetScrollPixelsPerUnityUnit1;
mywxScrolledWindow->GetScrollPixelsPerUnit( * wxScrolledWindowGetScrollPixelsPerUnitxUnit0,  * wxScrolledWindowGetScrollPixelsPerUnityUnit1);
// Looking at method wxScrolledWindow::GetViewStart
int*  * wxScrolledWindowGetViewStartx0;
int*   * wxScrolledWindowGetViewStarty1;
mywxScrolledWindow->GetViewStart( * wxScrolledWindowGetViewStartx0,  * wxScrolledWindowGetViewStarty1);
// Looking at method wxScrolledWindow::GetVirtualSize
int*  * wxScrolledWindowGetVirtualSizex0;
int*  * wxScrolledWindowGetVirtualSizey1;
mywxScrolledWindow->GetVirtualSize( * wxScrolledWindowGetVirtualSizex0,  * wxScrolledWindowGetVirtualSizey1);
// Looking at method wxScrolledWindow::IsRetained
bool retwxScrolledWindowIsRetained0 = mywxScrolledWindow->IsRetained();
// Looking at method wxScrolledWindow::DoPrepareDC
wxDC  * wxScrolledWindowDoPrepareDCdc0;
mywxScrolledWindow->DoPrepareDC( * wxScrolledWindowDoPrepareDCdc0);
// Looking at method wxScrolledWindow::OnDraw
// Looking at method wxScrolledWindow::PrepareDC
wxDC  * wxScrolledWindowPrepareDCdc0;
mywxScrolledWindow->PrepareDC( * wxScrolledWindowPrepareDCdc0);
// Looking at method wxScrolledWindow::Scroll
int  * wxScrolledWindowScrollx0;
int  * wxScrolledWindowScrolly1;
mywxScrolledWindow->Scroll( * wxScrolledWindowScrollx0,  * wxScrolledWindowScrolly1);
// Looking at method wxScrolledWindow::SetScrollbars
int  * wxScrolledWindowSetScrollbarspixelsPerUnitX0;
int  * wxScrolledWindowSetScrollbarspixelsPerUnitY1;
int  * wxScrolledWindowSetScrollbarsnoUnitsX2;
int  * wxScrolledWindowSetScrollbarsnoUnitsY3;
int  * wxScrolledWindowSetScrollbarsxPos4;
int  * wxScrolledWindowSetScrollbarsyPos5;
bool  * wxScrolledWindowSetScrollbarsnoRefresh6;
mywxScrolledWindow->SetScrollbars( * wxScrolledWindowSetScrollbarspixelsPerUnitX0,  * wxScrolledWindowSetScrollbarspixelsPerUnitY1,  * wxScrolledWindowSetScrollbarsnoUnitsX2,  * wxScrolledWindowSetScrollbarsnoUnitsY3,  * wxScrolledWindowSetScrollbarsxPos4,  * wxScrolledWindowSetScrollbarsyPos5,  * wxScrolledWindowSetScrollbarsnoRefresh6);
// Looking at method wxScrolledWindow::SetScrollRate
int  * wxScrolledWindowSetScrollRatexstep0;
int  * wxScrolledWindowSetScrollRateystep1;
mywxScrolledWindow->SetScrollRate( * wxScrolledWindowSetScrollRatexstep0,  * wxScrolledWindowSetScrollRateystep1);
// Looking at method wxScrolledWindow::SetTargetWindow
wxWindow*  * wxScrolledWindowSetTargetWindowwindow0;
mywxScrolledWindow->SetTargetWindow( * wxScrolledWindowSetTargetWindowwindow0);

// Looking at class wxSemaphore
wxSemaphore * mywxSemaphore;
// Looking at method wxSemaphore::wxSemaphore
int  * wxSemaphorewxSemaphoreinitialcount0;
int  * wxSemaphorewxSemaphoremaxcount1;
wxSemaphore * newwxSemaphore0 = new wxSemaphore( * wxSemaphorewxSemaphoreinitialcount0,  * wxSemaphorewxSemaphoremaxcount1);
// Looking at method wxSemaphore::Post
wxSemaError  retwxSemaphorePost0 = mywxSemaphore->Post();
// Looking at method wxSemaphore::TryWait
wxSemaError  retwxSemaphoreTryWait0 = mywxSemaphore->TryWait();
// Looking at method wxSemaphore::Wait
wxSemaError  retwxSemaphoreWait0 = mywxSemaphore->Wait();
// Looking at method wxSemaphore::WaitTimeout
unsigned long * wxSemaphoreWaitTimeouttimeout_millis0;
wxSemaError  retwxSemaphoreWaitTimeout0 = mywxSemaphore->WaitTimeout( * wxSemaphoreWaitTimeouttimeout_millis0);

// Looking at class wxServer
wxServer * mywxServer;
// Looking at method wxServer::wxServer
wxServer * newwxServer0 = new wxServer();
// Looking at method wxServer::Create
wxString  * wxServerCreateservice0;
bool retwxServerCreate0 = mywxServer->Create( * wxServerCreateservice0);
// Looking at method wxServer::OnAcceptConnection

// Looking at class wxSetCursorEvent
wxSetCursorEvent * mywxSetCursorEvent;
// Looking at method wxSetCursorEvent::wxSetCursorEvent
wxCoord * wxSetCursorEventwxSetCursorEventx0;
wxCoord * wxSetCursorEventwxSetCursorEventy1;
wxSetCursorEvent * newwxSetCursorEvent0 = new wxSetCursorEvent( * wxSetCursorEventwxSetCursorEventx0,  * wxSetCursorEventwxSetCursorEventy1);
// Looking at method wxSetCursorEvent::GetCursor
wxCursor retwxSetCursorEventGetCursor0 = mywxSetCursorEvent->GetCursor();
// Looking at method wxSetCursorEvent::GetX
wxCoord retwxSetCursorEventGetX0 = mywxSetCursorEvent->GetX();
// Looking at method wxSetCursorEvent::GetY
wxCoord retwxSetCursorEventGetY0 = mywxSetCursorEvent->GetY();
// Looking at method wxSetCursorEvent::HasCursor
bool retwxSetCursorEventHasCursor0 = mywxSetCursorEvent->HasCursor();
// Looking at method wxSetCursorEvent::SetCursor
wxCursor * wxSetCursorEventSetCursorcursor0;
mywxSetCursorEvent->SetCursor( * wxSetCursorEventSetCursorcursor0);

// Looking at class wxSimpleHelpProvider
wxSimpleHelpProvider * mywxSimpleHelpProvider;

// Looking at class wxSingleChoiceDialog
wxSingleChoiceDialog * mywxSingleChoiceDialog;
// Looking at method wxSingleChoiceDialog::wxSingleChoiceDialog
wxWindow*  * wxSingleChoiceDialogwxSingleChoiceDialogparent0;
wxString  * wxSingleChoiceDialogwxSingleChoiceDialogmessage1;
wxString  * wxSingleChoiceDialogwxSingleChoiceDialogcaption2;
int  * wxSingleChoiceDialogwxSingleChoiceDialogn3;
wxString*  * wxSingleChoiceDialogwxSingleChoiceDialogchoices4;
void**  * wxSingleChoiceDialogwxSingleChoiceDialogclientData5;
long  * wxSingleChoiceDialogwxSingleChoiceDialogstyle6;
wxPoint  * wxSingleChoiceDialogwxSingleChoiceDialogpos7;
wxSingleChoiceDialog * newwxSingleChoiceDialog0 = new wxSingleChoiceDialog( * wxSingleChoiceDialogwxSingleChoiceDialogparent0,  * wxSingleChoiceDialogwxSingleChoiceDialogmessage1,  * wxSingleChoiceDialogwxSingleChoiceDialogcaption2,  * wxSingleChoiceDialogwxSingleChoiceDialogn3,  * wxSingleChoiceDialogwxSingleChoiceDialogchoices4,  * wxSingleChoiceDialogwxSingleChoiceDialogclientData5,  * wxSingleChoiceDialogwxSingleChoiceDialogstyle6,  * wxSingleChoiceDialogwxSingleChoiceDialogpos7);
wxWindow*  * wxSingleChoiceDialogwxSingleChoiceDialogparent8;
wxString  * wxSingleChoiceDialogwxSingleChoiceDialogmessage9;
wxString  * wxSingleChoiceDialogwxSingleChoiceDialogcaption10;
wxArrayString  * wxSingleChoiceDialogwxSingleChoiceDialogchoices11;
void**  * wxSingleChoiceDialogwxSingleChoiceDialogclientData12;
long  * wxSingleChoiceDialogwxSingleChoiceDialogstyle13;
wxPoint  * wxSingleChoiceDialogwxSingleChoiceDialogpos14;
wxSingleChoiceDialog * newwxSingleChoiceDialog1 = new wxSingleChoiceDialog( * wxSingleChoiceDialogwxSingleChoiceDialogparent8,  * wxSingleChoiceDialogwxSingleChoiceDialogmessage9,  * wxSingleChoiceDialogwxSingleChoiceDialogcaption10,  * wxSingleChoiceDialogwxSingleChoiceDialogchoices11,  * wxSingleChoiceDialogwxSingleChoiceDialogclientData12,  * wxSingleChoiceDialogwxSingleChoiceDialogstyle13,  * wxSingleChoiceDialogwxSingleChoiceDialogpos14);
// Looking at method wxSingleChoiceDialog::GetSelection
int retwxSingleChoiceDialogGetSelection0 = mywxSingleChoiceDialog->GetSelection();
// Looking at method wxSingleChoiceDialog::GetSelectionClientData
char* retwxSingleChoiceDialogGetSelectionClientData0 = mywxSingleChoiceDialog->GetSelectionClientData();
// Looking at method wxSingleChoiceDialog::GetStringSelection
wxString retwxSingleChoiceDialogGetStringSelection0 = mywxSingleChoiceDialog->GetStringSelection();
// Looking at method wxSingleChoiceDialog::SetSelection
int  * wxSingleChoiceDialogSetSelectionselection0;
mywxSingleChoiceDialog->SetSelection( * wxSingleChoiceDialogSetSelectionselection0);
// Looking at method wxSingleChoiceDialog::ShowModal
int retwxSingleChoiceDialogShowModal0 = mywxSingleChoiceDialog->ShowModal();

// Looking at class wxSize
wxSize * mywxSize;
// Looking at method wxSize::wxSize
wxSize * newwxSize0 = new wxSize();
int  * wxSizewxSizewidth0;
int  * wxSizewxSizeheight1;
wxSize * newwxSize1 = new wxSize( * wxSizewxSizewidth0,  * wxSizewxSizeheight1);
// Looking at method wxSize::DecTo
wxSize  * wxSizeDecTosize0;
mywxSize->DecTo( * wxSizeDecTosize0);
// Looking at method wxSize::IsFullySpecified
bool retwxSizeIsFullySpecified0 = mywxSize->IsFullySpecified();
// Looking at method wxSize::GetWidth
int retwxSizeGetWidth0 = mywxSize->GetWidth();
// Looking at method wxSize::GetHeight
int retwxSizeGetHeight0 = mywxSize->GetHeight();
// Looking at method wxSize::IncTo
wxSize  * wxSizeIncTosize0;
mywxSize->IncTo( * wxSizeIncTosize0);
// Looking at method wxSize::Set
int  * wxSizeSetwidth0;
int  * wxSizeSetheight1;
mywxSize->Set( * wxSizeSetwidth0,  * wxSizeSetheight1);
// Looking at method wxSize::SetDefaults
wxSize  * wxSizeSetDefaultssizeDefault0;
mywxSize->SetDefaults( * wxSizeSetDefaultssizeDefault0);
// Looking at method wxSize::SetHeight
int  * wxSizeSetHeightheight0;
mywxSize->SetHeight( * wxSizeSetHeightheight0);
// Looking at method wxSize::SetWidth
int  * wxSizeSetWidthwidth0;
mywxSize->SetWidth( * wxSizeSetWidthwidth0);

// Looking at class wxSizeEvent
wxSizeEvent * mywxSizeEvent;
// Looking at method wxSizeEvent::wxSizeEvent
wxSize  * wxSizeEventwxSizeEventsz0;
int  * wxSizeEventwxSizeEventid1;
wxSizeEvent * newwxSizeEvent0 = new wxSizeEvent( * wxSizeEventwxSizeEventsz0,  * wxSizeEventwxSizeEventid1);
// Looking at method wxSizeEvent::GetSize
wxSize retwxSizeEventGetSize0 = mywxSizeEvent->GetSize();

// Looking at class wxSizerFlags
wxSizerFlags * mywxSizerFlags;
// Looking at method wxSizerFlags::wxSizerFlags
int  * wxSizerFlagswxSizerFlagsproportion0;
wxSizerFlags * newwxSizerFlags0 = new wxSizerFlags( * wxSizerFlagswxSizerFlagsproportion0);
// Looking at method wxSizerFlags::Align
int  * wxSizerFlagsAlignalign0;
wxSizerFlags  retwxSizerFlagsAlign0 = mywxSizerFlags->Align( * wxSizerFlagsAlignalign0);
// Looking at method wxSizerFlags::Border
int  * wxSizerFlagsBorderdirection0;
int  * wxSizerFlagsBorderborderinpixels1;
wxSizerFlags  retwxSizerFlagsBorder0 = mywxSizerFlags->Border( * wxSizerFlagsBorderdirection0,  * wxSizerFlagsBorderborderinpixels1);
int  * wxSizerFlagsBorderdirection2;
wxSizerFlags  retwxSizerFlagsBorder1 = mywxSizerFlags->Border( * wxSizerFlagsBorderdirection2);
// Looking at method wxSizerFlags::Center
wxSizerFlags  retwxSizerFlagsCenter0 = mywxSizerFlags->Center();
// Looking at method wxSizerFlags::Centre
wxSizerFlags  retwxSizerFlagsCentre0 = mywxSizerFlags->Centre();
// Looking at method wxSizerFlags::Expand
wxSizerFlags  retwxSizerFlagsExpand0 = mywxSizerFlags->Expand();
// Looking at method wxSizerFlags::Proportion
int  * wxSizerFlagsProportionproportion0;
wxSizerFlags  retwxSizerFlagsProportion0 = mywxSizerFlags->Proportion( * wxSizerFlagsProportionproportion0);

// Looking at class wxSizerItem
wxSizerItem * mywxSizerItem;
// Looking at method wxSizerItem::wxSizerItem
int  * wxSizerItemwxSizerItemwidth0;
int  * wxSizerItemwxSizerItemheight1;
int  * wxSizerItemwxSizerItemproportion2;
int  * wxSizerItemwxSizerItemflag3;
int  * wxSizerItemwxSizerItemborder4;
wxObject*  * wxSizerItemwxSizerItemuserData5;
wxSizerItem * newwxSizerItem0 = new wxSizerItem( * wxSizerItemwxSizerItemwidth0,  * wxSizerItemwxSizerItemheight1,  * wxSizerItemwxSizerItemproportion2,  * wxSizerItemwxSizerItemflag3,  * wxSizerItemwxSizerItemborder4,  * wxSizerItemwxSizerItemuserData5);
wxWindow*  * wxSizerItemwxSizerItemwindow6;
wxSizerFlags  * wxSizerItemwxSizerItemflags7;
wxSizerItem * newwxSizerItem1 = new wxSizerItem( * wxSizerItemwxSizerItemwindow6,  * wxSizerItemwxSizerItemflags7);
wxWindow*  * wxSizerItemwxSizerItemwindow8;
int  * wxSizerItemwxSizerItemproportion9;
int  * wxSizerItemwxSizerItemflag10;
int  * wxSizerItemwxSizerItemborder11;
wxObject*  * wxSizerItemwxSizerItemuserData12;
wxSizerItem * newwxSizerItem2 = new wxSizerItem( * wxSizerItemwxSizerItemwindow8,  * wxSizerItemwxSizerItemproportion9,  * wxSizerItemwxSizerItemflag10,  * wxSizerItemwxSizerItemborder11,  * wxSizerItemwxSizerItemuserData12);
wxSizer*  * wxSizerItemwxSizerItemwindow13;
wxSizerFlags  * wxSizerItemwxSizerItemflags14;
wxSizerItem * newwxSizerItem3 = new wxSizerItem( * wxSizerItemwxSizerItemwindow13,  * wxSizerItemwxSizerItemflags14);
wxSizer*  * wxSizerItemwxSizerItemsizer15;
int  * wxSizerItemwxSizerItemproportion16;
int  * wxSizerItemwxSizerItemflag17;
int  * wxSizerItemwxSizerItemborder18;
wxObject*  * wxSizerItemwxSizerItemuserData19;
wxSizerItem * newwxSizerItem4 = new wxSizerItem( * wxSizerItemwxSizerItemsizer15,  * wxSizerItemwxSizerItemproportion16,  * wxSizerItemwxSizerItemflag17,  * wxSizerItemwxSizerItemborder18,  * wxSizerItemwxSizerItemuserData19);
// Looking at method wxSizerItem::CalcMin
wxSize retwxSizerItemCalcMin0 = mywxSizerItem->CalcMin();
// Looking at method wxSizerItem::DeleteWindows
mywxSizerItem->DeleteWindows();
// Looking at method wxSizerItem::DetachSizer
mywxSizerItem->DetachSizer();
// Looking at method wxSizerItem::GetBorder
int retwxSizerItemGetBorder0 = mywxSizerItem->GetBorder();
// Looking at method wxSizerItem::GetFlag
int retwxSizerItemGetFlag0 = mywxSizerItem->GetFlag();
// Looking at method wxSizerItem::GetMinSize
wxSize retwxSizerItemGetMinSize0 = mywxSizerItem->GetMinSize();
// Looking at method wxSizerItem::GetPosition
wxPoint retwxSizerItemGetPosition0 = mywxSizerItem->GetPosition();
// Looking at method wxSizerItem::GetProportion
int retwxSizerItemGetProportion0 = mywxSizerItem->GetProportion();
// Looking at method wxSizerItem::GetRatio
float retwxSizerItemGetRatio0 = mywxSizerItem->GetRatio();
// Looking at method wxSizerItem::GetRect
wxRect retwxSizerItemGetRect0 = mywxSizerItem->GetRect();
// Looking at method wxSizerItem::GetSize
wxSize retwxSizerItemGetSize0 = mywxSizerItem->GetSize();
// Looking at method wxSizerItem::GetSizer
wxSizer* retwxSizerItemGetSizer0 = mywxSizerItem->GetSizer();
// Looking at method wxSizerItem::GetSpacer
const wxSize retwxSizerItemGetSpacer0 = mywxSizerItem->GetSpacer();
// Looking at method wxSizerItem::GetUserData
wxObject* retwxSizerItemGetUserData0 = mywxSizerItem->GetUserData();
// Looking at method wxSizerItem::GetWindow
wxWindow* retwxSizerItemGetWindow0 = mywxSizerItem->GetWindow();
// Looking at method wxSizerItem::IsShown
bool retwxSizerItemIsShown0 = mywxSizerItem->IsShown();
// Looking at method wxSizerItem::IsSizer
bool retwxSizerItemIsSizer0 = mywxSizerItem->IsSizer();
// Looking at method wxSizerItem::IsSpacer
bool retwxSizerItemIsSpacer0 = mywxSizerItem->IsSpacer();
// Looking at method wxSizerItem::IsWindow
bool retwxSizerItemIsWindow0 = mywxSizerItem->IsWindow();
// Looking at method wxSizerItem::SetBorder
int  * wxSizerItemSetBorderborder0;
mywxSizerItem->SetBorder( * wxSizerItemSetBorderborder0);
// Looking at method wxSizerItem::SetDimension
wxPoint  * wxSizerItemSetDimensionpos0;
wxSize  * wxSizerItemSetDimensionsize1;
mywxSizerItem->SetDimension( * wxSizerItemSetDimensionpos0,  * wxSizerItemSetDimensionsize1);
// Looking at method wxSizerItem::SetFlag
int  * wxSizerItemSetFlagflag0;
mywxSizerItem->SetFlag( * wxSizerItemSetFlagflag0);
// Looking at method wxSizerItem::SetInitSize
int  * wxSizerItemSetInitSizex0;
int  * wxSizerItemSetInitSizey1;
mywxSizerItem->SetInitSize( * wxSizerItemSetInitSizex0,  * wxSizerItemSetInitSizey1);
// Looking at method wxSizerItem::SetProportion
int  * wxSizerItemSetProportionproportion0;
mywxSizerItem->SetProportion( * wxSizerItemSetProportionproportion0);
// Looking at method wxSizerItem::SetRatio
int  * wxSizerItemSetRatiowidth0;
int  * wxSizerItemSetRatioheight1;
mywxSizerItem->SetRatio( * wxSizerItemSetRatiowidth0,  * wxSizerItemSetRatioheight1);
wxSize  * wxSizerItemSetRatiosize2;
mywxSizerItem->SetRatio( * wxSizerItemSetRatiosize2);
float  * wxSizerItemSetRatioratio3;
mywxSizerItem->SetRatio( * wxSizerItemSetRatioratio3);
// Looking at method wxSizerItem::SetSizer
wxSizer*  * wxSizerItemSetSizersizer0;
mywxSizerItem->SetSizer( * wxSizerItemSetSizersizer0);
// Looking at method wxSizerItem::SetSpacer
wxSize  * wxSizerItemSetSpacersize0;
mywxSizerItem->SetSpacer( * wxSizerItemSetSpacersize0);
// Looking at method wxSizerItem::SetWindow
wxWindow*  * wxSizerItemSetWindowwindow0;
mywxSizerItem->SetWindow( * wxSizerItemSetWindowwindow0);
// Looking at method wxSizerItem::Show
bool  * wxSizerItemShowshow0;
mywxSizerItem->Show( * wxSizerItemShowshow0);

// Looking at class wxSlider
wxSlider * mywxSlider;
// Looking at method wxSlider::wxSlider
wxSlider * newwxSlider0 = new wxSlider();
wxWindow*  * wxSliderwxSliderparent0;
wxWindowID  * wxSliderwxSliderid1;
int  * wxSliderwxSlidervalue2;
int  * wxSliderwxSliderminValue3;
int  * wxSliderwxSlidermaxValue4;
wxPoint  * wxSliderwxSliderpoint5;
wxSize  * wxSliderwxSlidersize6;
long  * wxSliderwxSliderstyle7;
wxValidator  * wxSliderwxSlidervalidator8;
wxString  * wxSliderwxSlidername9;
wxSlider * newwxSlider1 = new wxSlider( * wxSliderwxSliderparent0,  * wxSliderwxSliderid1,  * wxSliderwxSlidervalue2,  * wxSliderwxSliderminValue3,  * wxSliderwxSlidermaxValue4,  * wxSliderwxSliderpoint5,  * wxSliderwxSlidersize6,  * wxSliderwxSliderstyle7,  * wxSliderwxSlidervalidator8,  * wxSliderwxSlidername9);
// Looking at method wxSlider::ClearSel
mywxSlider->ClearSel();
// Looking at method wxSlider::ClearTicks
mywxSlider->ClearTicks();
// Looking at method wxSlider::Create
wxWindow*  * wxSliderCreateparent0;
wxWindowID  * wxSliderCreateid1;
int  * wxSliderCreatevalue2;
int  * wxSliderCreateminValue3;
int  * wxSliderCreatemaxValue4;
wxPoint  * wxSliderCreatepoint5;
wxSize  * wxSliderCreatesize6;
long  * wxSliderCreatestyle7;
wxValidator  * wxSliderCreatevalidator8;
wxString  * wxSliderCreatename9;
bool retwxSliderCreate0 = mywxSlider->Create( * wxSliderCreateparent0,  * wxSliderCreateid1,  * wxSliderCreatevalue2,  * wxSliderCreateminValue3,  * wxSliderCreatemaxValue4,  * wxSliderCreatepoint5,  * wxSliderCreatesize6,  * wxSliderCreatestyle7,  * wxSliderCreatevalidator8,  * wxSliderCreatename9);
// Looking at method wxSlider::GetLineSize
int retwxSliderGetLineSize0 = mywxSlider->GetLineSize();
// Looking at method wxSlider::GetMax
int retwxSliderGetMax0 = mywxSlider->GetMax();
// Looking at method wxSlider::GetMin
int retwxSliderGetMin0 = mywxSlider->GetMin();
// Looking at method wxSlider::GetPageSize
int retwxSliderGetPageSize0 = mywxSlider->GetPageSize();
// Looking at method wxSlider::GetSelEnd
int retwxSliderGetSelEnd0 = mywxSlider->GetSelEnd();
// Looking at method wxSlider::GetSelStart
int retwxSliderGetSelStart0 = mywxSlider->GetSelStart();
// Looking at method wxSlider::GetThumbLength
int retwxSliderGetThumbLength0 = mywxSlider->GetThumbLength();
// Looking at method wxSlider::GetTickFreq
int retwxSliderGetTickFreq0 = mywxSlider->GetTickFreq();
// Looking at method wxSlider::GetValue
int retwxSliderGetValue0 = mywxSlider->GetValue();
// Looking at method wxSlider::SetRange
int  * wxSliderSetRangeminValue0;
int  * wxSliderSetRangemaxValue1;
mywxSlider->SetRange( * wxSliderSetRangeminValue0,  * wxSliderSetRangemaxValue1);
// Looking at method wxSlider::SetTickFreq
int  * wxSliderSetTickFreqn0;
int  * wxSliderSetTickFreqpos1;
mywxSlider->SetTickFreq( * wxSliderSetTickFreqn0,  * wxSliderSetTickFreqpos1);
// Looking at method wxSlider::SetLineSize
int  * wxSliderSetLineSizelineSize0;
mywxSlider->SetLineSize( * wxSliderSetLineSizelineSize0);
// Looking at method wxSlider::SetPageSize
int  * wxSliderSetPageSizepageSize0;
mywxSlider->SetPageSize( * wxSliderSetPageSizepageSize0);
// Looking at method wxSlider::SetSelection
int  * wxSliderSetSelectionstartPos0;
int  * wxSliderSetSelectionendPos1;
mywxSlider->SetSelection( * wxSliderSetSelectionstartPos0,  * wxSliderSetSelectionendPos1);
// Looking at method wxSlider::SetThumbLength
int  * wxSliderSetThumbLengthlen0;
mywxSlider->SetThumbLength( * wxSliderSetThumbLengthlen0);
// Looking at method wxSlider::SetTick
int  * wxSliderSetTicktickPos0;
mywxSlider->SetTick( * wxSliderSetTicktickPos0);
// Looking at method wxSlider::SetValue
int  * wxSliderSetValuevalue0;
mywxSlider->SetValue( * wxSliderSetValuevalue0);

// Looking at class wxSocketClient
wxSocketClient * mywxSocketClient;
// Looking at method wxSocketClient::wxSocketClient
wxSocketFlags  * wxSocketClientwxSocketClientflags0;
wxSocketClient * newwxSocketClient0 = new wxSocketClient( * wxSocketClientwxSocketClientflags0);
// Looking at method wxSocketClient::Connect
wxSockAddress  * wxSocketClientConnectaddress0;
bool  * wxSocketClientConnectwait1;
bool retwxSocketClientConnect0 = mywxSocketClient->Connect( * wxSocketClientConnectaddress0,  * wxSocketClientConnectwait1);
// Looking at method wxSocketClient::WaitOnConnect
long  * wxSocketClientWaitOnConnectseconds0;
long  * wxSocketClientWaitOnConnectmilliseconds1;
bool retwxSocketClientWaitOnConnect0 = mywxSocketClient->WaitOnConnect( * wxSocketClientWaitOnConnectseconds0,  * wxSocketClientWaitOnConnectmilliseconds1);

// Looking at class wxSocketEvent
wxSocketEvent * mywxSocketEvent;
// Looking at method wxSocketEvent::wxSocketEvent
int  * wxSocketEventwxSocketEventid0;
wxSocketEvent * newwxSocketEvent0 = new wxSocketEvent( * wxSocketEventwxSocketEventid0);
// Looking at method wxSocketEvent::GetClientData
mywxSocketEvent->GetClientData();
// Looking at method wxSocketEvent::GetSocket
wxSocketBase * retwxSocketEventGetSocket0 = mywxSocketEvent->GetSocket();
// Looking at method wxSocketEvent::GetSocketEvent
wxSocketNotify retwxSocketEventGetSocketEvent0 = mywxSocketEvent->GetSocketEvent();

// Looking at class wxSocketInputStream
wxSocketInputStream * mywxSocketInputStream;
// Looking at method wxSocketInputStream::wxSocketInputStream
wxSocketBase  * wxSocketInputStreamwxSocketInputStreams0;
wxSocketInputStream * newwxSocketInputStream0 = new wxSocketInputStream( * wxSocketInputStreamwxSocketInputStreams0);

// Looking at class wxSocketOutputStream
wxSocketOutputStream * mywxSocketOutputStream;
// Looking at method wxSocketOutputStream::wxSocketOutputStream
wxSocketBase  * wxSocketOutputStreamwxSocketOutputStreams0;
wxSocketOutputStream * newwxSocketOutputStream0 = new wxSocketOutputStream( * wxSocketOutputStreamwxSocketOutputStreams0);

// Looking at class wxSocketServer
wxSocketServer * mywxSocketServer;
// Looking at method wxSocketServer::wxSocketServer
wxSockAddress  * wxSocketServerwxSocketServeraddress0;
wxSocketFlags  * wxSocketServerwxSocketServerflags1;
wxSocketServer * newwxSocketServer0 = new wxSocketServer( * wxSocketServerwxSocketServeraddress0,  * wxSocketServerwxSocketServerflags1);
// Looking at method wxSocketServer::Accept
bool  * wxSocketServerAcceptwait0;
wxSocketBase * retwxSocketServerAccept0 = mywxSocketServer->Accept( * wxSocketServerAcceptwait0);
// Looking at method wxSocketServer::AcceptWith
wxSocketBase  * wxSocketServerAcceptWithsocket0;
bool  * wxSocketServerAcceptWithwait1;
bool retwxSocketServerAcceptWith0 = mywxSocketServer->AcceptWith( * wxSocketServerAcceptWithsocket0,  * wxSocketServerAcceptWithwait1);
// Looking at method wxSocketServer::WaitForAccept
long  * wxSocketServerWaitForAcceptseconds0;
long  * wxSocketServerWaitForAcceptmillisecond1;
bool retwxSocketServerWaitForAccept0 = mywxSocketServer->WaitForAccept( * wxSocketServerWaitForAcceptseconds0,  * wxSocketServerWaitForAcceptmillisecond1);

// Looking at class wxSound
wxSound * mywxSound;
// Looking at method wxSound::wxSound
wxSound * newwxSound0 = new wxSound();
wxString  * wxSoundwxSoundfileName0;
bool  * wxSoundwxSoundisResource1;
wxSound * newwxSound1 = new wxSound( * wxSoundwxSoundfileName0,  * wxSoundwxSoundisResource1);
// Looking at method wxSound::Create
wxString  * wxSoundCreatefileName0;
bool  * wxSoundCreateisResource1;
bool retwxSoundCreate0 = mywxSound->Create( * wxSoundCreatefileName0,  * wxSoundCreateisResource1);
// Looking at method wxSound::IsOk
bool retwxSoundIsOk0 = mywxSound->IsOk();
// Looking at method wxSound::IsPlaying
static bool retwxSoundIsPlaying0 = mywxSound->IsPlaying();
// Looking at method wxSound::Play
unsigned   * wxSoundPlayflags0;
bool retwxSoundPlay0 = mywxSound->Play( * wxSoundPlayflags0);
wxString  * wxSoundPlayfilename1;
unsigned  * wxSoundPlayflags2;
static bool retwxSoundPlay1 = mywxSound->Play( * wxSoundPlayfilename1,  * wxSoundPlayflags2);
// Looking at method wxSound::Stop
mywxSound->Stop();

// Looking at class wxSpinButton
wxSpinButton * mywxSpinButton;

// Looking at class wxSpinCtrl
wxSpinCtrl * mywxSpinCtrl;
// Looking at method wxSpinCtrl::wxSpinCtrl
wxSpinCtrl * newwxSpinCtrl0 = new wxSpinCtrl();
wxWindow*  * wxSpinCtrlwxSpinCtrlparent0;
wxWindowID  * wxSpinCtrlwxSpinCtrlid1;
wxString  * wxSpinCtrlwxSpinCtrlvalue2;
wxPoint  * wxSpinCtrlwxSpinCtrlpos3;
wxSize  * wxSpinCtrlwxSpinCtrlsize4;
long  * wxSpinCtrlwxSpinCtrlstyle5;
int  * wxSpinCtrlwxSpinCtrlmin6;
int  * wxSpinCtrlwxSpinCtrlmax7;
int  * wxSpinCtrlwxSpinCtrlinitial8;
wxString  * wxSpinCtrlwxSpinCtrlname9;
wxSpinCtrl * newwxSpinCtrl1 = new wxSpinCtrl( * wxSpinCtrlwxSpinCtrlparent0,  * wxSpinCtrlwxSpinCtrlid1,  * wxSpinCtrlwxSpinCtrlvalue2,  * wxSpinCtrlwxSpinCtrlpos3,  * wxSpinCtrlwxSpinCtrlsize4,  * wxSpinCtrlwxSpinCtrlstyle5,  * wxSpinCtrlwxSpinCtrlmin6,  * wxSpinCtrlwxSpinCtrlmax7,  * wxSpinCtrlwxSpinCtrlinitial8,  * wxSpinCtrlwxSpinCtrlname9);
// Looking at method wxSpinCtrl::Create
wxWindow*  * wxSpinCtrlCreateparent0;
wxWindowID  * wxSpinCtrlCreateid1;
wxString  * wxSpinCtrlCreatevalue2;
wxPoint  * wxSpinCtrlCreatepos3;
wxSize  * wxSpinCtrlCreatesize4;
long  * wxSpinCtrlCreatestyle5;
int  * wxSpinCtrlCreatemin6;
int  * wxSpinCtrlCreatemax7;
int  * wxSpinCtrlCreateinitial8;
wxString  * wxSpinCtrlCreatename9;
bool retwxSpinCtrlCreate0 = mywxSpinCtrl->Create( * wxSpinCtrlCreateparent0,  * wxSpinCtrlCreateid1,  * wxSpinCtrlCreatevalue2,  * wxSpinCtrlCreatepos3,  * wxSpinCtrlCreatesize4,  * wxSpinCtrlCreatestyle5,  * wxSpinCtrlCreatemin6,  * wxSpinCtrlCreatemax7,  * wxSpinCtrlCreateinitial8,  * wxSpinCtrlCreatename9);
// Looking at method wxSpinCtrl::SetValue
wxString  * wxSpinCtrlSetValuetext0;
mywxSpinCtrl->SetValue( * wxSpinCtrlSetValuetext0);
int  * wxSpinCtrlSetValuevalue1;
mywxSpinCtrl->SetValue( * wxSpinCtrlSetValuevalue1);
// Looking at method wxSpinCtrl::GetValue
int retwxSpinCtrlGetValue0 = mywxSpinCtrl->GetValue();
// Looking at method wxSpinCtrl::SetRange
int  * wxSpinCtrlSetRangeminVal0;
int  * wxSpinCtrlSetRangemaxVal1;
mywxSpinCtrl->SetRange( * wxSpinCtrlSetRangeminVal0,  * wxSpinCtrlSetRangemaxVal1);
// Looking at method wxSpinCtrl::SetSelection
long  * wxSpinCtrlSetSelectionfrom0;
long  * wxSpinCtrlSetSelectionto1;
mywxSpinCtrl->SetSelection( * wxSpinCtrlSetSelectionfrom0,  * wxSpinCtrlSetSelectionto1);
// Looking at method wxSpinCtrl::GetMin
int retwxSpinCtrlGetMin0 = mywxSpinCtrl->GetMin();
// Looking at method wxSpinCtrl::GetMax
int retwxSpinCtrlGetMax0 = mywxSpinCtrl->GetMax();

// Looking at class wxSpinEvent
wxSpinEvent * mywxSpinEvent;
// Looking at method wxSpinEvent::wxSpinEvent
wxEventType  * wxSpinEventwxSpinEventcommandType0;
int  * wxSpinEventwxSpinEventid1;
wxSpinEvent * newwxSpinEvent0 = new wxSpinEvent( * wxSpinEventwxSpinEventcommandType0,  * wxSpinEventwxSpinEventid1);
// Looking at method wxSpinEvent::GetPosition
int retwxSpinEventGetPosition0 = mywxSpinEvent->GetPosition();
// Looking at method wxSpinEvent::SetPosition
int  * wxSpinEventSetPositionpos0;
mywxSpinEvent->SetPosition( * wxSpinEventSetPositionpos0);

// Looking at class wxSplashScreen
wxSplashScreen * mywxSplashScreen;
// Looking at method wxSplashScreen::wxSplashScreen
wxBitmap  * wxSplashScreenwxSplashScreenbitmap0;
long  * wxSplashScreenwxSplashScreensplashStyle1;
int  * wxSplashScreenwxSplashScreenmilliseconds2;
wxWindow*  * wxSplashScreenwxSplashScreenparent3;
wxWindowID  * wxSplashScreenwxSplashScreenid4;
wxPoint  * wxSplashScreenwxSplashScreenpos5;
wxSize  * wxSplashScreenwxSplashScreensize6;
long  * wxSplashScreenwxSplashScreenstyle7;
wxSplashScreen * newwxSplashScreen0 = new wxSplashScreen( * wxSplashScreenwxSplashScreenbitmap0,  * wxSplashScreenwxSplashScreensplashStyle1,  * wxSplashScreenwxSplashScreenmilliseconds2,  * wxSplashScreenwxSplashScreenparent3,  * wxSplashScreenwxSplashScreenid4,  * wxSplashScreenwxSplashScreenpos5,  * wxSplashScreenwxSplashScreensize6,  * wxSplashScreenwxSplashScreenstyle7);
// Looking at method wxSplashScreen::OnCloseWindow
wxCloseEvent  * wxSplashScreenOnCloseWindowevent0;
mywxSplashScreen->OnCloseWindow( * wxSplashScreenOnCloseWindowevent0);
// Looking at method wxSplashScreen::GetSplashStyle
long retwxSplashScreenGetSplashStyle0 = mywxSplashScreen->GetSplashStyle();
// Looking at method wxSplashScreen::GetSplashWindow
wxSplashScreenWindow* retwxSplashScreenGetSplashWindow0 = mywxSplashScreen->GetSplashWindow();
// Looking at method wxSplashScreen::GetTimeout
int retwxSplashScreenGetTimeout0 = mywxSplashScreen->GetTimeout();

// Looking at class wxSplitterEvent
wxSplitterEvent * mywxSplitterEvent;
// Looking at method wxSplitterEvent::wxSplitterEvent
wxEventType  * wxSplitterEventwxSplitterEventeventType0;
wxSplitterWindow *  * wxSplitterEventwxSplitterEventsplitter1;
wxSplitterEvent * newwxSplitterEvent0 = new wxSplitterEvent( * wxSplitterEventwxSplitterEventeventType0,  * wxSplitterEventwxSplitterEventsplitter1);
// Looking at method wxSplitterEvent::GetSashPosition
int retwxSplitterEventGetSashPosition0 = mywxSplitterEvent->GetSashPosition();
// Looking at method wxSplitterEvent::GetX
int retwxSplitterEventGetX0 = mywxSplitterEvent->GetX();
// Looking at method wxSplitterEvent::GetY
int retwxSplitterEventGetY0 = mywxSplitterEvent->GetY();
// Looking at method wxSplitterEvent::GetWindowBeingRemoved
wxWindow* retwxSplitterEventGetWindowBeingRemoved0 = mywxSplitterEvent->GetWindowBeingRemoved();
// Looking at method wxSplitterEvent::SetSashPosition
int  * wxSplitterEventSetSashPositionpos0;
mywxSplitterEvent->SetSashPosition( * wxSplitterEventSetSashPositionpos0);

// Looking at class wxSplitterRenderParams
wxSplitterRenderParams * mywxSplitterRenderParams;
// Looking at method wxSplitterRenderParams::widthSash
// Looking at method wxSplitterRenderParams::border
// Looking at method wxSplitterRenderParams::isHotSensitive

// Looking at class wxSplitterWindow
wxSplitterWindow * mywxSplitterWindow;
// Looking at method wxSplitterWindow::wxSplitterWindow
wxSplitterWindow * newwxSplitterWindow0 = new wxSplitterWindow();
wxWindow*  * wxSplitterWindowwxSplitterWindowparent0;
wxWindowID  * wxSplitterWindowwxSplitterWindowid1;
wxPoint  * wxSplitterWindowwxSplitterWindowpoint2;
wxSize  * wxSplitterWindowwxSplitterWindowsize3;
long  * wxSplitterWindowwxSplitterWindowstyle4;
wxString  * wxSplitterWindowwxSplitterWindowname5;
wxSplitterWindow * newwxSplitterWindow1 = new wxSplitterWindow( * wxSplitterWindowwxSplitterWindowparent0,  * wxSplitterWindowwxSplitterWindowid1,  * wxSplitterWindowwxSplitterWindowpoint2,  * wxSplitterWindowwxSplitterWindowsize3,  * wxSplitterWindowwxSplitterWindowstyle4,  * wxSplitterWindowwxSplitterWindowname5);
// Looking at method wxSplitterWindow::Create
wxWindow*  * wxSplitterWindowCreateparent0;
wxWindowID  * wxSplitterWindowCreateid1;
wxPoint  * wxSplitterWindowCreatepoint2;
wxSize  * wxSplitterWindowCreatesize3;
long  * wxSplitterWindowCreatestyle4;
wxString  * wxSplitterWindowCreatename5;
bool retwxSplitterWindowCreate0 = mywxSplitterWindow->Create( * wxSplitterWindowCreateparent0,  * wxSplitterWindowCreateid1,  * wxSplitterWindowCreatepoint2,  * wxSplitterWindowCreatesize3,  * wxSplitterWindowCreatestyle4,  * wxSplitterWindowCreatename5);
// Looking at method wxSplitterWindow::GetMinimumPaneSize
int retwxSplitterWindowGetMinimumPaneSize0 = mywxSplitterWindow->GetMinimumPaneSize();
// Looking at method wxSplitterWindow::GetSashGravity
double retwxSplitterWindowGetSashGravity0 = mywxSplitterWindow->GetSashGravity();
// Looking at method wxSplitterWindow::GetSashPosition
int retwxSplitterWindowGetSashPosition0 = mywxSplitterWindow->GetSashPosition();
// Looking at method wxSplitterWindow::GetSplitMode
int retwxSplitterWindowGetSplitMode0 = mywxSplitterWindow->GetSplitMode();
// Looking at method wxSplitterWindow::GetWindow1
wxWindow* retwxSplitterWindowGetWindow10 = mywxSplitterWindow->GetWindow1();
// Looking at method wxSplitterWindow::GetWindow2
wxWindow* retwxSplitterWindowGetWindow20 = mywxSplitterWindow->GetWindow2();
// Looking at method wxSplitterWindow::Initialize
wxWindow*  * wxSplitterWindowInitializewindow0;
mywxSplitterWindow->Initialize( * wxSplitterWindowInitializewindow0);
// Looking at method wxSplitterWindow::IsSplit
bool retwxSplitterWindowIsSplit0 = mywxSplitterWindow->IsSplit();
// Looking at method wxSplitterWindow::OnDoubleClickSash
// Looking at method wxSplitterWindow::OnUnsplit
// Looking at method wxSplitterWindow::OnSashPositionChange
// Looking at method wxSplitterWindow::ReplaceWindow
wxWindow *  * wxSplitterWindowReplaceWindowwinOld0;
wxWindow *  * wxSplitterWindowReplaceWindowwinNew1;
bool retwxSplitterWindowReplaceWindow0 = mywxSplitterWindow->ReplaceWindow( * wxSplitterWindowReplaceWindowwinOld0,  * wxSplitterWindowReplaceWindowwinNew1);
// Looking at method wxSplitterWindow::SetSashGravity
double  * wxSplitterWindowSetSashGravitygravity0;
mywxSplitterWindow->SetSashGravity( * wxSplitterWindowSetSashGravitygravity0);
// Looking at method wxSplitterWindow::SetSashPosition
int  * wxSplitterWindowSetSashPositionposition0;
bool  * wxSplitterWindowSetSashPositionredraw1;
mywxSplitterWindow->SetSashPosition( * wxSplitterWindowSetSashPositionposition0,  * wxSplitterWindowSetSashPositionredraw1);
// Looking at method wxSplitterWindow::SetMinimumPaneSize
int  * wxSplitterWindowSetMinimumPaneSizepaneSize0;
mywxSplitterWindow->SetMinimumPaneSize( * wxSplitterWindowSetMinimumPaneSizepaneSize0);
// Looking at method wxSplitterWindow::SetSplitMode
int  * wxSplitterWindowSetSplitModemode0;
mywxSplitterWindow->SetSplitMode( * wxSplitterWindowSetSplitModemode0);
// Looking at method wxSplitterWindow::SplitHorizontally
wxWindow*  * wxSplitterWindowSplitHorizontallywindow10;
wxWindow*  * wxSplitterWindowSplitHorizontallywindow21;
int  * wxSplitterWindowSplitHorizontallysashPosition2;
bool retwxSplitterWindowSplitHorizontally0 = mywxSplitterWindow->SplitHorizontally( * wxSplitterWindowSplitHorizontallywindow10,  * wxSplitterWindowSplitHorizontallywindow21,  * wxSplitterWindowSplitHorizontallysashPosition2);
// Looking at method wxSplitterWindow::SplitVertically
wxWindow*  * wxSplitterWindowSplitVerticallywindow10;
wxWindow*  * wxSplitterWindowSplitVerticallywindow21;
int  * wxSplitterWindowSplitVerticallysashPosition2;
bool retwxSplitterWindowSplitVertically0 = mywxSplitterWindow->SplitVertically( * wxSplitterWindowSplitVerticallywindow10,  * wxSplitterWindowSplitVerticallywindow21,  * wxSplitterWindowSplitVerticallysashPosition2);
// Looking at method wxSplitterWindow::Unsplit
wxWindow*  * wxSplitterWindowUnsplittoRemove0;
bool retwxSplitterWindowUnsplit0 = mywxSplitterWindow->Unsplit( * wxSplitterWindowUnsplittoRemove0);
// Looking at method wxSplitterWindow::UpdateSize
mywxSplitterWindow->UpdateSize();

// Looking at class wxStackFrame
wxStackFrame * mywxStackFrame;
// Looking at method wxStackFrame::GetAddress
mywxStackFrame->GetAddress();
// Looking at method wxStackFrame::GetFileName
wxString retwxStackFrameGetFileName0 = mywxStackFrame->GetFileName();
// Looking at method wxStackFrame::GetLevel
size_t retwxStackFrameGetLevel0 = mywxStackFrame->GetLevel();
// Looking at method wxStackFrame::GetLine
size_t retwxStackFrameGetLine0 = mywxStackFrame->GetLine();
// Looking at method wxStackFrame::GetModule
wxString retwxStackFrameGetModule0 = mywxStackFrame->GetModule();
// Looking at method wxStackFrame::GetName
wxString retwxStackFrameGetName0 = mywxStackFrame->GetName();
// Looking at method wxStackFrame::GetOffset
size_t retwxStackFrameGetOffset0 = mywxStackFrame->GetOffset();
// Looking at method wxStackFrame::GetParam
size_t  * wxStackFrameGetParamn0;
wxString *  * wxStackFrameGetParamtype1;
wxString *  * wxStackFrameGetParamname2;
wxString *  * wxStackFrameGetParamvalue3;
bool retwxStackFrameGetParam0 = mywxStackFrame->GetParam( * wxStackFrameGetParamn0,  * wxStackFrameGetParamtype1,  * wxStackFrameGetParamname2,  * wxStackFrameGetParamvalue3);
// Looking at method wxStackFrame::GetParamCount
size_t retwxStackFrameGetParamCount0 = mywxStackFrame->GetParamCount();
// Looking at method wxStackFrame::HasSourceLocation
bool retwxStackFrameHasSourceLocation0 = mywxStackFrame->HasSourceLocation();

// Looking at class wxStandardPaths
wxStandardPaths * mywxStandardPaths;
// Looking at method wxStandardPaths::GetConfigDir
static wxString retwxStandardPathsGetConfigDir0 = mywxStandardPaths->GetConfigDir();
// Looking at method wxStandardPaths::GetDataDir
static wxString retwxStandardPathsGetDataDir0 = mywxStandardPaths->GetDataDir();
// Looking at method wxStandardPaths::GetInstallPrefix
static wxString retwxStandardPathsGetInstallPrefix0 = mywxStandardPaths->GetInstallPrefix();
// Looking at method wxStandardPaths::GetLocalDataDir
static wxString retwxStandardPathsGetLocalDataDir0 = mywxStandardPaths->GetLocalDataDir();
// Looking at method wxStandardPaths::GetPluginsDir
static wxString retwxStandardPathsGetPluginsDir0 = mywxStandardPaths->GetPluginsDir();
// Looking at method wxStandardPaths::GetUserConfigDir
static wxString retwxStandardPathsGetUserConfigDir0 = mywxStandardPaths->GetUserConfigDir();
// Looking at method wxStandardPaths::GetUserDataDir
static wxString retwxStandardPathsGetUserDataDir0 = mywxStandardPaths->GetUserDataDir();
// Looking at method wxStandardPaths::GetUserLocalDataDir
static wxString retwxStandardPathsGetUserLocalDataDir0 = mywxStandardPaths->GetUserLocalDataDir();
// Looking at method wxStandardPaths::SetInstallPrefix
wxString  * wxStandardPathsSetInstallPrefixprefix0;
mywxStandardPaths->SetInstallPrefix( * wxStandardPathsSetInstallPrefixprefix0);

// Looking at class wxStaticBitmap
wxStaticBitmap * mywxStaticBitmap;
// Looking at method wxStaticBitmap::wxStaticBitmap
wxStaticBitmap * newwxStaticBitmap0 = new wxStaticBitmap();
wxWindow*  * wxStaticBitmapwxStaticBitmapparent0;
wxWindowID  * wxStaticBitmapwxStaticBitmapid1;
wxBitmap  * wxStaticBitmapwxStaticBitmaplabel2;
wxPoint  * wxStaticBitmapwxStaticBitmappos3;
wxSize  * wxStaticBitmapwxStaticBitmapsize4;
long  * wxStaticBitmapwxStaticBitmapstyle5;
wxString  * wxStaticBitmapwxStaticBitmapname6;
wxStaticBitmap * newwxStaticBitmap1 = new wxStaticBitmap( * wxStaticBitmapwxStaticBitmapparent0,  * wxStaticBitmapwxStaticBitmapid1,  * wxStaticBitmapwxStaticBitmaplabel2,  * wxStaticBitmapwxStaticBitmappos3,  * wxStaticBitmapwxStaticBitmapsize4,  * wxStaticBitmapwxStaticBitmapstyle5,  * wxStaticBitmapwxStaticBitmapname6);
// Looking at method wxStaticBitmap::Create
wxWindow*  * wxStaticBitmapCreateparent0;
wxWindowID  * wxStaticBitmapCreateid1;
wxBitmap  * wxStaticBitmapCreatelabel2;
wxPoint  * wxStaticBitmapCreatepos3;
wxSize  * wxStaticBitmapCreatesize4;
long  * wxStaticBitmapCreatestyle5;
wxString  * wxStaticBitmapCreatename6;
bool retwxStaticBitmapCreate0 = mywxStaticBitmap->Create( * wxStaticBitmapCreateparent0,  * wxStaticBitmapCreateid1,  * wxStaticBitmapCreatelabel2,  * wxStaticBitmapCreatepos3,  * wxStaticBitmapCreatesize4,  * wxStaticBitmapCreatestyle5,  * wxStaticBitmapCreatename6);
// Looking at method wxStaticBitmap::GetBitmap
wxBitmap retwxStaticBitmapGetBitmap0 = mywxStaticBitmap->GetBitmap();
// Looking at method wxStaticBitmap::SetBitmap

// Looking at class wxStaticBox
wxStaticBox * mywxStaticBox;
// Looking at method wxStaticBox::wxStaticBox
wxStaticBox * newwxStaticBox0 = new wxStaticBox();
wxWindow*  * wxStaticBoxwxStaticBoxparent0;
wxWindowID  * wxStaticBoxwxStaticBoxid1;
wxString  * wxStaticBoxwxStaticBoxlabel2;
wxPoint  * wxStaticBoxwxStaticBoxpos3;
wxSize  * wxStaticBoxwxStaticBoxsize4;
long  * wxStaticBoxwxStaticBoxstyle5;
wxString  * wxStaticBoxwxStaticBoxname6;
wxStaticBox * newwxStaticBox1 = new wxStaticBox( * wxStaticBoxwxStaticBoxparent0,  * wxStaticBoxwxStaticBoxid1,  * wxStaticBoxwxStaticBoxlabel2,  * wxStaticBoxwxStaticBoxpos3,  * wxStaticBoxwxStaticBoxsize4,  * wxStaticBoxwxStaticBoxstyle5,  * wxStaticBoxwxStaticBoxname6);
// Looking at method wxStaticBox::Create
wxWindow*  * wxStaticBoxCreateparent0;
wxWindowID  * wxStaticBoxCreateid1;
wxString  * wxStaticBoxCreatelabel2;
wxPoint  * wxStaticBoxCreatepos3;
wxSize  * wxStaticBoxCreatesize4;
long  * wxStaticBoxCreatestyle5;
wxString  * wxStaticBoxCreatename6;
bool retwxStaticBoxCreate0 = mywxStaticBox->Create( * wxStaticBoxCreateparent0,  * wxStaticBoxCreateid1,  * wxStaticBoxCreatelabel2,  * wxStaticBoxCreatepos3,  * wxStaticBoxCreatesize4,  * wxStaticBoxCreatestyle5,  * wxStaticBoxCreatename6);

// Looking at class wxStaticBoxSizer
wxStaticBoxSizer * mywxStaticBoxSizer;
// Looking at method wxStaticBoxSizer::wxStaticBoxSizer
wxStaticBox*  * wxStaticBoxSizerwxStaticBoxSizerbox0;
int  * wxStaticBoxSizerwxStaticBoxSizerorient1;
wxStaticBoxSizer * newwxStaticBoxSizer0 = new wxStaticBoxSizer( * wxStaticBoxSizerwxStaticBoxSizerbox0,  * wxStaticBoxSizerwxStaticBoxSizerorient1);
int  * wxStaticBoxSizerwxStaticBoxSizerorient2;
wxWindow * * wxStaticBoxSizerwxStaticBoxSizerparent3;
wxString  * wxStaticBoxSizerwxStaticBoxSizerlabel4;
wxStaticBoxSizer * newwxStaticBoxSizer1 = new wxStaticBoxSizer( * wxStaticBoxSizerwxStaticBoxSizerorient2,  * wxStaticBoxSizerwxStaticBoxSizerparent3,  * wxStaticBoxSizerwxStaticBoxSizerlabel4);
// Looking at method wxStaticBoxSizer::GetStaticBox
wxStaticBox* retwxStaticBoxSizerGetStaticBox0 = mywxStaticBoxSizer->GetStaticBox();

// Looking at class wxStaticLine
wxStaticLine * mywxStaticLine;
// Looking at method wxStaticLine::wxStaticLine
wxStaticLine * newwxStaticLine0 = new wxStaticLine();
wxWindow*  * wxStaticLinewxStaticLineparent0;
wxWindowID  * wxStaticLinewxStaticLineid1;
wxPoint  * wxStaticLinewxStaticLinepos2;
wxSize  * wxStaticLinewxStaticLinesize3;
long  * wxStaticLinewxStaticLinestyle4;
wxString  * wxStaticLinewxStaticLinename5;
wxStaticLine * newwxStaticLine1 = new wxStaticLine( * wxStaticLinewxStaticLineparent0,  * wxStaticLinewxStaticLineid1,  * wxStaticLinewxStaticLinepos2,  * wxStaticLinewxStaticLinesize3,  * wxStaticLinewxStaticLinestyle4,  * wxStaticLinewxStaticLinename5);
// Looking at method wxStaticLine::Create
wxWindow*  * wxStaticLineCreateparent0;
wxWindowID  * wxStaticLineCreateid1;
wxPoint  * wxStaticLineCreatepos2;
wxSize  * wxStaticLineCreatesize3;
long  * wxStaticLineCreatestyle4;
wxString  * wxStaticLineCreatename5;
bool retwxStaticLineCreate0 = mywxStaticLine->Create( * wxStaticLineCreateparent0,  * wxStaticLineCreateid1,  * wxStaticLineCreatepos2,  * wxStaticLineCreatesize3,  * wxStaticLineCreatestyle4,  * wxStaticLineCreatename5);
// Looking at method wxStaticLine::IsVertical
bool retwxStaticLineIsVertical0 = mywxStaticLine->IsVertical();
// Looking at method wxStaticLine::GetDefaultSize
int retwxStaticLineGetDefaultSize0 = mywxStaticLine->GetDefaultSize();

// Looking at class wxStaticText
wxStaticText * mywxStaticText;
// Looking at method wxStaticText::wxStaticText
wxStaticText * newwxStaticText0 = new wxStaticText();
wxWindow*  * wxStaticTextwxStaticTextparent0;
wxWindowID  * wxStaticTextwxStaticTextid1;
wxString  * wxStaticTextwxStaticTextlabel2;
wxPoint  * wxStaticTextwxStaticTextpos3;
wxSize  * wxStaticTextwxStaticTextsize4;
long  * wxStaticTextwxStaticTextstyle5;
wxString  * wxStaticTextwxStaticTextname6;
wxStaticText * newwxStaticText1 = new wxStaticText( * wxStaticTextwxStaticTextparent0,  * wxStaticTextwxStaticTextid1,  * wxStaticTextwxStaticTextlabel2,  * wxStaticTextwxStaticTextpos3,  * wxStaticTextwxStaticTextsize4,  * wxStaticTextwxStaticTextstyle5,  * wxStaticTextwxStaticTextname6);
// Looking at method wxStaticText::Create
wxWindow*  * wxStaticTextCreateparent0;
wxWindowID  * wxStaticTextCreateid1;
wxString  * wxStaticTextCreatelabel2;
wxPoint  * wxStaticTextCreatepos3;
wxSize  * wxStaticTextCreatesize4;
long  * wxStaticTextCreatestyle5;
wxString  * wxStaticTextCreatename6;
bool retwxStaticTextCreate0 = mywxStaticText->Create( * wxStaticTextCreateparent0,  * wxStaticTextCreateid1,  * wxStaticTextCreatelabel2,  * wxStaticTextCreatepos3,  * wxStaticTextCreatesize4,  * wxStaticTextCreatestyle5,  * wxStaticTextCreatename6);
// Looking at method wxStaticText::GetLabel
wxString retwxStaticTextGetLabel0 = mywxStaticText->GetLabel();
// Looking at method wxStaticText::SetLabel

// Looking at class wxStatusBar
wxStatusBar * mywxStatusBar;
// Looking at method wxStatusBar::wxStatusBar
wxStatusBar * newwxStatusBar0 = new wxStatusBar();
wxWindow*  * wxStatusBarwxStatusBarparent0;
wxWindowID  * wxStatusBarwxStatusBarid1;
long  * wxStatusBarwxStatusBarstyle2;
wxString  * wxStatusBarwxStatusBarname3;
wxStatusBar * newwxStatusBar1 = new wxStatusBar( * wxStatusBarwxStatusBarparent0,  * wxStatusBarwxStatusBarid1,  * wxStatusBarwxStatusBarstyle2,  * wxStatusBarwxStatusBarname3);
// Looking at method wxStatusBar::Create
wxWindow*  * wxStatusBarCreateparent0;
wxWindowID  * wxStatusBarCreateid1;
long  * wxStatusBarCreatestyle2;
wxString  * wxStatusBarCreatename3;
bool retwxStatusBarCreate0 = mywxStatusBar->Create( * wxStatusBarCreateparent0,  * wxStatusBarCreateid1,  * wxStatusBarCreatestyle2,  * wxStatusBarCreatename3);
// Looking at method wxStatusBar::GetFieldRect
// Looking at method wxStatusBar::GetFieldsCount
int retwxStatusBarGetFieldsCount0 = mywxStatusBar->GetFieldsCount();
// Looking at method wxStatusBar::GetStatusText
// Looking at method wxStatusBar::PopStatusText
int  * wxStatusBarPopStatusTextfield0;
mywxStatusBar->PopStatusText( * wxStatusBarPopStatusTextfield0);
// Looking at method wxStatusBar::PushStatusText
wxString  * wxStatusBarPushStatusTextstring0;
int  * wxStatusBarPushStatusTextfield1;
mywxStatusBar->PushStatusText( * wxStatusBarPushStatusTextstring0,  * wxStatusBarPushStatusTextfield1);
// Looking at method wxStatusBar::SetFieldsCount
// Looking at method wxStatusBar::SetMinHeight
int  * wxStatusBarSetMinHeightheight0;
mywxStatusBar->SetMinHeight( * wxStatusBarSetMinHeightheight0);
// Looking at method wxStatusBar::SetStatusText
// Looking at method wxStatusBar::SetStatusWidths
// Looking at method wxStatusBar::SetStatusStyles

// Looking at class wxStdDialogButtonSizer
wxStdDialogButtonSizer * mywxStdDialogButtonSizer;
// Looking at method wxStdDialogButtonSizer::wxStdDialogButtonSizer
wxStdDialogButtonSizer * newwxStdDialogButtonSizer0 = new wxStdDialogButtonSizer();
// Looking at method wxStdDialogButtonSizer::AddButton
wxButton*  * wxStdDialogButtonSizerAddButtonbutton0;
mywxStdDialogButtonSizer->AddButton( * wxStdDialogButtonSizerAddButtonbutton0);
// Looking at method wxStdDialogButtonSizer::Realize
mywxStdDialogButtonSizer->Realize();
// Looking at method wxStdDialogButtonSizer::SetAffirmativeButton
wxButton*  * wxStdDialogButtonSizerSetAffirmativeButtonbutton0;
mywxStdDialogButtonSizer->SetAffirmativeButton( * wxStdDialogButtonSizerSetAffirmativeButtonbutton0);
// Looking at method wxStdDialogButtonSizer::SetCancelButton
wxButton*  * wxStdDialogButtonSizerSetCancelButtonbutton0;
mywxStdDialogButtonSizer->SetCancelButton( * wxStdDialogButtonSizerSetCancelButtonbutton0);
// Looking at method wxStdDialogButtonSizer::SetNegativeButton
wxButton*  * wxStdDialogButtonSizerSetNegativeButtonbutton0;
mywxStdDialogButtonSizer->SetNegativeButton( * wxStdDialogButtonSizerSetNegativeButtonbutton0);

// Looking at class wxStopWatch
wxStopWatch * mywxStopWatch;
// Looking at method wxStopWatch::wxStopWatch
wxStopWatch * newwxStopWatch0 = new wxStopWatch();
// Looking at method wxStopWatch::Pause
mywxStopWatch->Pause();
// Looking at method wxStopWatch::Resume
mywxStopWatch->Resume();
// Looking at method wxStopWatch::Start
long  * wxStopWatchStartmilliseconds0;
mywxStopWatch->Start( * wxStopWatchStartmilliseconds0);
// Looking at method wxStopWatch::Time
long retwxStopWatchTime0 = mywxStopWatch->Time();

// Looking at class wxStreamBuffer
wxStreamBuffer * mywxStreamBuffer;
// Looking at method wxStreamBuffer::wxStreamBuffer
wxStreamBase  * wxStreamBufferwxStreamBufferstream0;
BufMode  * wxStreamBufferwxStreamBuffermode1;
wxStreamBuffer * newwxStreamBuffer0 = new wxStreamBuffer( * wxStreamBufferwxStreamBufferstream0,  * wxStreamBufferwxStreamBuffermode1);
BufMode  * wxStreamBufferwxStreamBuffermode2;
wxStreamBuffer * newwxStreamBuffer1 = new wxStreamBuffer( * wxStreamBufferwxStreamBuffermode2);
wxStreamBuffer * wxStreamBufferwxStreamBufferbuffer3;
wxStreamBuffer * newwxStreamBuffer2 = new wxStreamBuffer( * wxStreamBufferwxStreamBufferbuffer3);
// Looking at method wxStreamBuffer::Read
void * * wxStreamBufferReadbuffer0;
size_t  * wxStreamBufferReadsize1;
size_t retwxStreamBufferRead0 = mywxStreamBuffer->Read( * wxStreamBufferReadbuffer0,  * wxStreamBufferReadsize1);
wxStreamBuffer * * wxStreamBufferReadbuffer2;
size_t retwxStreamBufferRead1 = mywxStreamBuffer->Read( * wxStreamBufferReadbuffer2);
// Looking at method wxStreamBuffer::Write
void * * wxStreamBufferWritebuffer0;
size_t  * wxStreamBufferWritesize1;
size_t retwxStreamBufferWrite0 = mywxStreamBuffer->Write( * wxStreamBufferWritebuffer0,  * wxStreamBufferWritesize1);
wxStreamBuffer * * wxStreamBufferWritebuffer2;
size_t retwxStreamBufferWrite1 = mywxStreamBuffer->Write( * wxStreamBufferWritebuffer2);
// Looking at method wxStreamBuffer::GetChar
char retwxStreamBufferGetChar0 = mywxStreamBuffer->GetChar();
// Looking at method wxStreamBuffer::PutChar
char  * wxStreamBufferPutCharc0;
mywxStreamBuffer->PutChar( * wxStreamBufferPutCharc0);
// Looking at method wxStreamBuffer::Tell
off_t retwxStreamBufferTell0 = mywxStreamBuffer->Tell();
// Looking at method wxStreamBuffer::Seek
off_t  * wxStreamBufferSeekpos0;
wxSeekMode  * wxStreamBufferSeekmode1;
off_t retwxStreamBufferSeek0 = mywxStreamBuffer->Seek( * wxStreamBufferSeekpos0,  * wxStreamBufferSeekmode1);
// Looking at method wxStreamBuffer::ResetBuffer
mywxStreamBuffer->ResetBuffer();
// Looking at method wxStreamBuffer::SetBufferIO
char*  * wxStreamBufferSetBufferIObuffer_start0;
char*  * wxStreamBufferSetBufferIObuffer_end1;
mywxStreamBuffer->SetBufferIO( * wxStreamBufferSetBufferIObuffer_start0,  * wxStreamBufferSetBufferIObuffer_end1);
size_t  * wxStreamBufferSetBufferIObufsize2;
mywxStreamBuffer->SetBufferIO( * wxStreamBufferSetBufferIObufsize2);
// Looking at method wxStreamBuffer::GetBufferStart
mywxStreamBuffer->GetBufferStart();
// Looking at method wxStreamBuffer::GetBufferEnd
mywxStreamBuffer->GetBufferEnd();
// Looking at method wxStreamBuffer::GetBufferPos
mywxStreamBuffer->GetBufferPos();
// Looking at method wxStreamBuffer::GetIntPosition
off_t retwxStreamBufferGetIntPosition0 = mywxStreamBuffer->GetIntPosition();
// Looking at method wxStreamBuffer::SetIntPosition
size_t  * wxStreamBufferSetIntPositionpos0;
mywxStreamBuffer->SetIntPosition( * wxStreamBufferSetIntPositionpos0);
// Looking at method wxStreamBuffer::GetLastAccess
size_t retwxStreamBufferGetLastAccess0 = mywxStreamBuffer->GetLastAccess();
// Looking at method wxStreamBuffer::Fixed
bool  * wxStreamBufferFixedfixed0;
mywxStreamBuffer->Fixed( * wxStreamBufferFixedfixed0);
// Looking at method wxStreamBuffer::Flushable
bool  * wxStreamBufferFlushableflushable0;
mywxStreamBuffer->Flushable( * wxStreamBufferFlushableflushable0);
// Looking at method wxStreamBuffer::FlushBuffer
bool retwxStreamBufferFlushBuffer0 = mywxStreamBuffer->FlushBuffer();
// Looking at method wxStreamBuffer::FillBuffer
bool retwxStreamBufferFillBuffer0 = mywxStreamBuffer->FillBuffer();
// Looking at method wxStreamBuffer::GetDataLeft
size_t retwxStreamBufferGetDataLeft0 = mywxStreamBuffer->GetDataLeft();
// Looking at method wxStreamBuffer::Stream
wxStreamBase* retwxStreamBufferStream0 = mywxStreamBuffer->Stream();

// Looking at class wxStringBufferLength
wxStringBufferLength * mywxStringBufferLength;
// Looking at method wxStringBufferLength::wxStringBufferLength
wxString  * wxStringBufferLengthwxStringBufferLengthstr0;
size_t  * wxStringBufferLengthwxStringBufferLengthlen1;
wxStringBufferLength * newwxStringBufferLength0 = new wxStringBufferLength( * wxStringBufferLengthwxStringBufferLengthstr0,  * wxStringBufferLengthwxStringBufferLengthlen1);
// Looking at method wxStringBufferLength::SetLength
size_t  * wxStringBufferLengthSetLengthnLength0;
mywxStringBufferLength->SetLength( * wxStringBufferLengthSetLengthnLength0);

// Looking at class wxStringClientData
wxStringClientData * mywxStringClientData;
// Looking at method wxStringClientData::wxStringClientData
wxStringClientData * newwxStringClientData0 = new wxStringClientData();
wxString  * wxStringClientDatawxStringClientDatadata0;
wxStringClientData * newwxStringClientData1 = new wxStringClientData( * wxStringClientDatawxStringClientDatadata0);
// Looking at method wxStringClientData::GetData
const wxString retwxStringClientDataGetData0 = mywxStringClientData->GetData();
// Looking at method wxStringClientData::SetData
wxString  * wxStringClientDataSetDatadata0;
mywxStringClientData->SetData( * wxStringClientDataSetDatadata0);

// Looking at class wxStringInputStream
wxStringInputStream * mywxStringInputStream;
// Looking at method wxStringInputStream::wxStringInputStream
wxString  * wxStringInputStreamwxStringInputStreams0;
wxStringInputStream * newwxStringInputStream0 = new wxStringInputStream( * wxStringInputStreamwxStringInputStreams0);

// Looking at class wxStringOutputStream
wxStringOutputStream * mywxStringOutputStream;
// Looking at method wxStringOutputStream::wxStringOutputStream
wxString * * wxStringOutputStreamwxStringOutputStreamstr0;
wxStringOutputStream * newwxStringOutputStream0 = new wxStringOutputStream( * wxStringOutputStreamwxStringOutputStreamstr0);
// Looking at method wxStringOutputStream::GetString
const wxString retwxStringOutputStreamGetString0 = mywxStringOutputStream->GetString();

// Looking at class wxStringTokenizer
wxStringTokenizer * mywxStringTokenizer;
// Looking at method wxStringTokenizer::wxStringTokenizer
wxStringTokenizer * newwxStringTokenizer0 = new wxStringTokenizer();
wxString  * wxStringTokenizerwxStringTokenizerstr0;
wxString  * wxStringTokenizerwxStringTokenizerdelims1;
wxStringTokenizerMode  * wxStringTokenizerwxStringTokenizermode2;
wxStringTokenizer * newwxStringTokenizer1 = new wxStringTokenizer( * wxStringTokenizerwxStringTokenizerstr0,  * wxStringTokenizerwxStringTokenizerdelims1,  * wxStringTokenizerwxStringTokenizermode2);
// Looking at method wxStringTokenizer::CountTokens
int retwxStringTokenizerCountTokens0 = mywxStringTokenizer->CountTokens();
// Looking at method wxStringTokenizer::HasMoreTokens
bool retwxStringTokenizerHasMoreTokens0 = mywxStringTokenizer->HasMoreTokens();
// Looking at method wxStringTokenizer::GetNextToken
wxString retwxStringTokenizerGetNextToken0 = mywxStringTokenizer->GetNextToken();
// Looking at method wxStringTokenizer::GetPosition
size_t retwxStringTokenizerGetPosition0 = mywxStringTokenizer->GetPosition();
// Looking at method wxStringTokenizer::GetString
wxString retwxStringTokenizerGetString0 = mywxStringTokenizer->GetString();
// Looking at method wxStringTokenizer::SetString
wxString  * wxStringTokenizerSetStringto_tokenize0;
wxString  * wxStringTokenizerSetStringdelims1;
wxStringTokenizerMode  * wxStringTokenizerSetStringmode2;
mywxStringTokenizer->SetString( * wxStringTokenizerSetStringto_tokenize0,  * wxStringTokenizerSetStringdelims1,  * wxStringTokenizerSetStringmode2);

// Looking at class wxSysColourChangedEvent
wxSysColourChangedEvent * mywxSysColourChangedEvent;
// Looking at method wxSysColourChangedEvent::wxSysColourChangedEvent
wxSysColourChangedEvent * newwxSysColourChangedEvent0 = new wxSysColourChangedEvent();

// Looking at class wxSystemOptions
wxSystemOptions * mywxSystemOptions;
// Looking at method wxSystemOptions::wxSystemOptions
wxSystemOptions * newwxSystemOptions0 = new wxSystemOptions();
// Looking at method wxSystemOptions::GetOption
wxString  * wxSystemOptionsGetOptionname0;
wxString retwxSystemOptionsGetOption0 = mywxSystemOptions->GetOption( * wxSystemOptionsGetOptionname0);
// Looking at method wxSystemOptions::GetOptionInt
wxString  * wxSystemOptionsGetOptionIntname0;
int retwxSystemOptionsGetOptionInt0 = mywxSystemOptions->GetOptionInt( * wxSystemOptionsGetOptionIntname0);
// Looking at method wxSystemOptions::HasOption
wxString  * wxSystemOptionsHasOptionname0;
bool retwxSystemOptionsHasOption0 = mywxSystemOptions->HasOption( * wxSystemOptionsHasOptionname0);
// Looking at method wxSystemOptions::SetOption
wxString  * wxSystemOptionsSetOptionname0;
wxString  * wxSystemOptionsSetOptionvalue1;
mywxSystemOptions->SetOption( * wxSystemOptionsSetOptionname0,  * wxSystemOptionsSetOptionvalue1);
wxString  * wxSystemOptionsSetOptionname2;
int  * wxSystemOptionsSetOptionvalue3;
mywxSystemOptions->SetOption( * wxSystemOptionsSetOptionname2,  * wxSystemOptionsSetOptionvalue3);

// Looking at class wxSystemSettings
wxSystemSettings * mywxSystemSettings;
// Looking at method wxSystemSettings::wxSystemSettings
wxSystemSettings * newwxSystemSettings0 = new wxSystemSettings();
// Looking at method wxSystemSettings::GetColour
wxSystemColour  * wxSystemSettingsGetColourindex0;
static wxColour retwxSystemSettingsGetColour0 = mywxSystemSettings->GetColour( * wxSystemSettingsGetColourindex0);
// Looking at method wxSystemSettings::GetFont
wxSystemFont  * wxSystemSettingsGetFontindex0;
static wxFont retwxSystemSettingsGetFont0 = mywxSystemSettings->GetFont( * wxSystemSettingsGetFontindex0);
// Looking at method wxSystemSettings::GetMetric
wxSystemMetric  * wxSystemSettingsGetMetricindex0;
static int retwxSystemSettingsGetMetric0 = mywxSystemSettings->GetMetric( * wxSystemSettingsGetMetricindex0);

// Looking at class wxTCPClient
wxTCPClient * mywxTCPClient;
// Looking at method wxTCPClient::wxTCPClient
wxTCPClient * newwxTCPClient0 = new wxTCPClient();
// Looking at method wxTCPClient::MakeConnection
wxString  * wxTCPClientMakeConnectionhost0;
wxString  * wxTCPClientMakeConnectionservice1;
wxString  * wxTCPClientMakeConnectiontopic2;
wxConnectionBase * retwxTCPClientMakeConnection0 = mywxTCPClient->MakeConnection( * wxTCPClientMakeConnectionhost0,  * wxTCPClientMakeConnectionservice1,  * wxTCPClientMakeConnectiontopic2);
// Looking at method wxTCPClient::OnMakeConnection
wxConnectionBase * retwxTCPClientOnMakeConnection0 = mywxTCPClient->OnMakeConnection();
// Looking at method wxTCPClient::ValidHost
wxString  * wxTCPClientValidHosthost0;
bool retwxTCPClientValidHost0 = mywxTCPClient->ValidHost( * wxTCPClientValidHosthost0);

// Looking at class wxTCPConnection
wxTCPConnection * mywxTCPConnection;
// Looking at method wxTCPConnection::wxTCPConnection
wxTCPConnection * newwxTCPConnection0 = new wxTCPConnection();
char*  * wxTCPConnectionwxTCPConnectionbuffer0;
int  * wxTCPConnectionwxTCPConnectionsize1;
wxTCPConnection * newwxTCPConnection1 = new wxTCPConnection( * wxTCPConnectionwxTCPConnectionbuffer0,  * wxTCPConnectionwxTCPConnectionsize1);
// Looking at method wxTCPConnection::Advise
wxString  * wxTCPConnectionAdviseitem0;
char*  * wxTCPConnectionAdvisedata1;
int  * wxTCPConnectionAdvisesize2;
wxIPCFormat  * wxTCPConnectionAdviseformat3;
bool retwxTCPConnectionAdvise0 = mywxTCPConnection->Advise( * wxTCPConnectionAdviseitem0,  * wxTCPConnectionAdvisedata1,  * wxTCPConnectionAdvisesize2,  * wxTCPConnectionAdviseformat3);
// Looking at method wxTCPConnection::Execute
char*  * wxTCPConnectionExecutedata0;
int  * wxTCPConnectionExecutesize1;
wxIPCFormat  * wxTCPConnectionExecuteformat2;
bool retwxTCPConnectionExecute0 = mywxTCPConnection->Execute( * wxTCPConnectionExecutedata0,  * wxTCPConnectionExecutesize1,  * wxTCPConnectionExecuteformat2);
// Looking at method wxTCPConnection::Disconnect
bool retwxTCPConnectionDisconnect0 = mywxTCPConnection->Disconnect();
// Looking at method wxTCPConnection::OnAdvise
// Looking at method wxTCPConnection::OnDisconnect
// Looking at method wxTCPConnection::OnExecute
// Looking at method wxTCPConnection::OnPoke
// Looking at method wxTCPConnection::OnRequest
// Looking at method wxTCPConnection::OnStartAdvise
// Looking at method wxTCPConnection::OnStopAdvise
// Looking at method wxTCPConnection::Poke
wxString  * wxTCPConnectionPokeitem0;
char*  * wxTCPConnectionPokedata1;
int  * wxTCPConnectionPokesize2;
wxIPCFormat  * wxTCPConnectionPokeformat3;
bool retwxTCPConnectionPoke0 = mywxTCPConnection->Poke( * wxTCPConnectionPokeitem0,  * wxTCPConnectionPokedata1,  * wxTCPConnectionPokesize2,  * wxTCPConnectionPokeformat3);
// Looking at method wxTCPConnection::Request
wxString  * wxTCPConnectionRequestitem0;
int * * wxTCPConnectionRequestsize1;
wxIPCFormat  * wxTCPConnectionRequestformat2;
char* retwxTCPConnectionRequest0 = mywxTCPConnection->Request( * wxTCPConnectionRequestitem0,  * wxTCPConnectionRequestsize1,  * wxTCPConnectionRequestformat2);
// Looking at method wxTCPConnection::StartAdvise
wxString  * wxTCPConnectionStartAdviseitem0;
bool retwxTCPConnectionStartAdvise0 = mywxTCPConnection->StartAdvise( * wxTCPConnectionStartAdviseitem0);
// Looking at method wxTCPConnection::StopAdvise
wxString  * wxTCPConnectionStopAdviseitem0;
bool retwxTCPConnectionStopAdvise0 = mywxTCPConnection->StopAdvise( * wxTCPConnectionStopAdviseitem0);

// Looking at class wxTCPServer
wxTCPServer * mywxTCPServer;
// Looking at method wxTCPServer::wxTCPServer
wxTCPServer * newwxTCPServer0 = new wxTCPServer();
// Looking at method wxTCPServer::Create
wxString  * wxTCPServerCreateservice0;
bool retwxTCPServerCreate0 = mywxTCPServer->Create( * wxTCPServerCreateservice0);
// Looking at method wxTCPServer::OnAcceptConnection

// Looking at class wxTaskBarIcon
wxTaskBarIcon * mywxTaskBarIcon;
// Looking at method wxTaskBarIcon::wxTaskBarIcon
wxTaskBarIcon * newwxTaskBarIcon0 = new wxTaskBarIcon();
// Looking at method wxTaskBarIcon::CreatePopupMenu
// Looking at method wxTaskBarIcon::IsIconInstalled
bool retwxTaskBarIconIsIconInstalled0 = mywxTaskBarIcon->IsIconInstalled();
// Looking at method wxTaskBarIcon::IsOk
bool retwxTaskBarIconIsOk0 = mywxTaskBarIcon->IsOk();
// Looking at method wxTaskBarIcon::PopupMenu
wxMenu*  * wxTaskBarIconPopupMenumenu0;
bool retwxTaskBarIconPopupMenu0 = mywxTaskBarIcon->PopupMenu( * wxTaskBarIconPopupMenumenu0);
// Looking at method wxTaskBarIcon::RemoveIcon
bool retwxTaskBarIconRemoveIcon0 = mywxTaskBarIcon->RemoveIcon();
// Looking at method wxTaskBarIcon::SetIcon
wxIcon  * wxTaskBarIconSetIconicon0;
wxString  * wxTaskBarIconSetIcontooltip1;
bool retwxTaskBarIconSetIcon0 = mywxTaskBarIcon->SetIcon( * wxTaskBarIconSetIconicon0,  * wxTaskBarIconSetIcontooltip1);

// Looking at class wxTempFile
wxTempFile * mywxTempFile;
// Looking at method wxTempFile::wxTempFile
wxTempFile * newwxTempFile0 = new wxTempFile();
wxString  * wxTempFilewxTempFilestrName0;
wxTempFile * newwxTempFile1 = new wxTempFile( * wxTempFilewxTempFilestrName0);
// Looking at method wxTempFile::Open
wxString  * wxTempFileOpenstrName0;
bool retwxTempFileOpen0 = mywxTempFile->Open( * wxTempFileOpenstrName0);
// Looking at method wxTempFile::IsOpened
bool retwxTempFileIsOpened0 = mywxTempFile->IsOpened();
// Looking at method wxTempFile::Write
void * * wxTempFileWritep0;
size_t  * wxTempFileWriten1;
bool retwxTempFileWrite0 = mywxTempFile->Write( * wxTempFileWritep0,  * wxTempFileWriten1);
wxString  * wxTempFileWritestr2;
wxMBConv  * wxTempFileWriteconv3;
bool retwxTempFileWrite1 = mywxTempFile->Write( * wxTempFileWritestr2,  * wxTempFileWriteconv3);
// Looking at method wxTempFile::Commit
bool retwxTempFileCommit0 = mywxTempFile->Commit();
// Looking at method wxTempFile::Discard
mywxTempFile->Discard();

// Looking at class wxTextAttr
wxTextAttr * mywxTextAttr;
// Looking at method wxTextAttr::wxTextAttr
wxTextAttr * newwxTextAttr0 = new wxTextAttr();
wxColour  * wxTextAttrwxTextAttrcolText0;
wxColour  * wxTextAttrwxTextAttrcolBack1;
wxFont  * wxTextAttrwxTextAttrfont2;
wxTextAttrAlignment  * wxTextAttrwxTextAttralignment3;
wxTextAttr * newwxTextAttr1 = new wxTextAttr( * wxTextAttrwxTextAttrcolText0,  * wxTextAttrwxTextAttrcolBack1,  * wxTextAttrwxTextAttrfont2,  * wxTextAttrwxTextAttralignment3);
// Looking at method wxTextAttr::GetAlignment
wxTextAttrAlignment retwxTextAttrGetAlignment0 = mywxTextAttr->GetAlignment();
// Looking at method wxTextAttr::GetBackgroundColour
const wxColour retwxTextAttrGetBackgroundColour0 = mywxTextAttr->GetBackgroundColour();
// Looking at method wxTextAttr::GetFont
const wxFont retwxTextAttrGetFont0 = mywxTextAttr->GetFont();
// Looking at method wxTextAttr::GetLeftIndent
int retwxTextAttrGetLeftIndent0 = mywxTextAttr->GetLeftIndent();
// Looking at method wxTextAttr::GetLeftSubIndent
int retwxTextAttrGetLeftSubIndent0 = mywxTextAttr->GetLeftSubIndent();
// Looking at method wxTextAttr::GetRightIndent
int retwxTextAttrGetRightIndent0 = mywxTextAttr->GetRightIndent();
// Looking at method wxTextAttr::GetTabs
const wxArrayInt retwxTextAttrGetTabs0 = mywxTextAttr->GetTabs();
// Looking at method wxTextAttr::GetTextColour
const wxColour retwxTextAttrGetTextColour0 = mywxTextAttr->GetTextColour();
// Looking at method wxTextAttr::HasBackgroundColour
bool retwxTextAttrHasBackgroundColour0 = mywxTextAttr->HasBackgroundColour();
// Looking at method wxTextAttr::HasFont
bool retwxTextAttrHasFont0 = mywxTextAttr->HasFont();
// Looking at method wxTextAttr::HasTextColour
bool retwxTextAttrHasTextColour0 = mywxTextAttr->HasTextColour();
// Looking at method wxTextAttr::GetFlags
long retwxTextAttrGetFlags0 = mywxTextAttr->GetFlags();
// Looking at method wxTextAttr::IsDefault
bool retwxTextAttrIsDefault0 = mywxTextAttr->IsDefault();
// Looking at method wxTextAttr::SetAlignment
wxTextAttrAlignment  * wxTextAttrSetAlignmentalignment0;
mywxTextAttr->SetAlignment( * wxTextAttrSetAlignmentalignment0);
// Looking at method wxTextAttr::SetBackgroundColour
wxColour  * wxTextAttrSetBackgroundColourcolour0;
mywxTextAttr->SetBackgroundColour( * wxTextAttrSetBackgroundColourcolour0);
// Looking at method wxTextAttr::SetFlags
long  * wxTextAttrSetFlagsflags0;
mywxTextAttr->SetFlags( * wxTextAttrSetFlagsflags0);
// Looking at method wxTextAttr::SetFont
wxFont  * wxTextAttrSetFontfont0;
mywxTextAttr->SetFont( * wxTextAttrSetFontfont0);
// Looking at method wxTextAttr::SetLeftIndent
int  * wxTextAttrSetLeftIndentindent0;
int  * wxTextAttrSetLeftIndentsubIndent1;
mywxTextAttr->SetLeftIndent( * wxTextAttrSetLeftIndentindent0,  * wxTextAttrSetLeftIndentsubIndent1);
// Looking at method wxTextAttr::SetRightIndent
int  * wxTextAttrSetRightIndentindent0;
mywxTextAttr->SetRightIndent( * wxTextAttrSetRightIndentindent0);
// Looking at method wxTextAttr::SetTabs
wxArrayInt  * wxTextAttrSetTabstabs0;
mywxTextAttr->SetTabs( * wxTextAttrSetTabstabs0);
// Looking at method wxTextAttr::SetTextColour
wxColour  * wxTextAttrSetTextColourcolour0;
mywxTextAttr->SetTextColour( * wxTextAttrSetTextColourcolour0);

// Looking at class wxTextDataObject
wxTextDataObject * mywxTextDataObject;
// Looking at method wxTextDataObject::wxTextDataObject
wxString  * wxTextDataObjectwxTextDataObjecttext0;
wxTextDataObject * newwxTextDataObject0 = new wxTextDataObject( * wxTextDataObjectwxTextDataObjecttext0);
// Looking at method wxTextDataObject::GetTextLength
// Looking at method wxTextDataObject::GetText
// Looking at method wxTextDataObject::SetText

// Looking at class wxTextEntryDialog
wxTextEntryDialog * mywxTextEntryDialog;
// Looking at method wxTextEntryDialog::wxTextEntryDialog
wxWindow*  * wxTextEntryDialogwxTextEntryDialogparent0;
wxString  * wxTextEntryDialogwxTextEntryDialogmessage1;
wxString  * wxTextEntryDialogwxTextEntryDialogcaption2;
wxString  * wxTextEntryDialogwxTextEntryDialogdefaultValue3;
long  * wxTextEntryDialogwxTextEntryDialogstyle4;
wxPoint  * wxTextEntryDialogwxTextEntryDialogpos5;
wxTextEntryDialog * newwxTextEntryDialog0 = new wxTextEntryDialog( * wxTextEntryDialogwxTextEntryDialogparent0,  * wxTextEntryDialogwxTextEntryDialogmessage1,  * wxTextEntryDialogwxTextEntryDialogcaption2,  * wxTextEntryDialogwxTextEntryDialogdefaultValue3,  * wxTextEntryDialogwxTextEntryDialogstyle4,  * wxTextEntryDialogwxTextEntryDialogpos5);
// Looking at method wxTextEntryDialog::GetValue
wxString retwxTextEntryDialogGetValue0 = mywxTextEntryDialog->GetValue();
// Looking at method wxTextEntryDialog::SetValue
wxString  * wxTextEntryDialogSetValuevalue0;
mywxTextEntryDialog->SetValue( * wxTextEntryDialogSetValuevalue0);
// Looking at method wxTextEntryDialog::ShowModal
int retwxTextEntryDialogShowModal0 = mywxTextEntryDialog->ShowModal();

// Looking at class wxTextFile
wxTextFile * mywxTextFile;
// Looking at method wxTextFile::wxTextFile
wxTextFile * newwxTextFile0 = new wxTextFile();
wxString  * wxTextFilewxTextFilestrFile0;
wxTextFile * newwxTextFile1 = new wxTextFile( * wxTextFilewxTextFilestrFile0);
// Looking at method wxTextFile::AddLine
wxString  * wxTextFileAddLinestr0;
wxTextFileType  * wxTextFileAddLinetype1;
mywxTextFile->AddLine( * wxTextFileAddLinestr0,  * wxTextFileAddLinetype1);
// Looking at method wxTextFile::Close
bool retwxTextFileClose0 = mywxTextFile->Close();
// Looking at method wxTextFile::Create
bool retwxTextFileCreate0 = mywxTextFile->Create();
wxString  * wxTextFileCreatestrFile0;
bool retwxTextFileCreate1 = mywxTextFile->Create( * wxTextFileCreatestrFile0);
// Looking at method wxTextFile::Exists
bool retwxTextFileExists0 = mywxTextFile->Exists();
// Looking at method wxTextFile::IsOpened
bool retwxTextFileIsOpened0 = mywxTextFile->IsOpened();
// Looking at method wxTextFile::GetLineCount
size_t retwxTextFileGetLineCount0 = mywxTextFile->GetLineCount();
// Looking at method wxTextFile::GetLine
size_t  * wxTextFileGetLinen0;
wxString retwxTextFileGetLine0 = mywxTextFile->GetLine( * wxTextFileGetLinen0);
// Looking at method wxTextFile::GetCurrentLine
size_t retwxTextFileGetCurrentLine0 = mywxTextFile->GetCurrentLine();
// Looking at method wxTextFile::GoToLine
size_t  * wxTextFileGoToLinen0;
mywxTextFile->GoToLine( * wxTextFileGoToLinen0);
// Looking at method wxTextFile::Eof
bool retwxTextFileEof0 = mywxTextFile->Eof();
// Looking at method wxTextFile::GetEOL
wxTextFileType  * wxTextFileGetEOLtype0;
static const char* retwxTextFileGetEOL0 = mywxTextFile->GetEOL( * wxTextFileGetEOLtype0);
// Looking at method wxTextFile::GetFirstLine
wxString retwxTextFileGetFirstLine0 = mywxTextFile->GetFirstLine();
// Looking at method wxTextFile::GetNextLine
wxString retwxTextFileGetNextLine0 = mywxTextFile->GetNextLine();
// Looking at method wxTextFile::GetPrevLine
wxString retwxTextFileGetPrevLine0 = mywxTextFile->GetPrevLine();
// Looking at method wxTextFile::GetLastLine
wxString retwxTextFileGetLastLine0 = mywxTextFile->GetLastLine();
// Looking at method wxTextFile::GetLineType
size_t  * wxTextFileGetLineTypen0;
wxTextFileType retwxTextFileGetLineType0 = mywxTextFile->GetLineType( * wxTextFileGetLineTypen0);
// Looking at method wxTextFile::GuessType
wxTextFileType retwxTextFileGuessType0 = mywxTextFile->GuessType();
// Looking at method wxTextFile::GetName
const char* retwxTextFileGetName0 = mywxTextFile->GetName();
// Looking at method wxTextFile::InsertLine
wxString  * wxTextFileInsertLinestr0;
size_t  * wxTextFileInsertLinen1;
wxTextFileType  * wxTextFileInsertLinetype2;
mywxTextFile->InsertLine( * wxTextFileInsertLinestr0,  * wxTextFileInsertLinen1,  * wxTextFileInsertLinetype2);
// Looking at method wxTextFile::Open
wxMBConv  * wxTextFileOpenconv0;
bool retwxTextFileOpen0 = mywxTextFile->Open( * wxTextFileOpenconv0);
wxString  * wxTextFileOpenstrFile1;
wxMBConv  * wxTextFileOpenconv2;
bool retwxTextFileOpen1 = mywxTextFile->Open( * wxTextFileOpenstrFile1,  * wxTextFileOpenconv2);
// Looking at method wxTextFile::RemoveLine
size_t  * wxTextFileRemoveLinen0;
mywxTextFile->RemoveLine( * wxTextFileRemoveLinen0);
// Looking at method wxTextFile::Clear
mywxTextFile->Clear();
// Looking at method wxTextFile::Write
wxTextFileType  * wxTextFileWritetypeNew0;
wxMBConv  * wxTextFileWriteconv1;
bool retwxTextFileWrite0 = mywxTextFile->Write( * wxTextFileWritetypeNew0,  * wxTextFileWriteconv1);

// Looking at class wxTextInputStream
wxTextInputStream * mywxTextInputStream;
// Looking at method wxTextInputStream::wxTextInputStream
wxInputStream  * wxTextInputStreamwxTextInputStreamstream0;
wxString  * wxTextInputStreamwxTextInputStreamsep1;
wxTextInputStream * newwxTextInputStream0 = new wxTextInputStream( * wxTextInputStreamwxTextInputStreamstream0,  * wxTextInputStreamwxTextInputStreamsep1);
#if wxUSE_UNICODE == 1
wxInputStream  * wxTextInputStreamwxTextInputStreamstream2;
wxString  * wxTextInputStreamwxTextInputStreamsep3;
wxMBConv  * wxTextInputStreamwxTextInputStreamconv4;
wxTextInputStream * newwxTextInputStream1 = new wxTextInputStream( * wxTextInputStreamwxTextInputStreamstream2,  * wxTextInputStreamwxTextInputStreamsep3,  * wxTextInputStreamwxTextInputStreamconv4);
#endif //wxUSE_UNICODE
// Looking at method wxTextInputStream::Read8
int  * wxTextInputStreamRead8base0;
wxUint8 retwxTextInputStreamRead80 = mywxTextInputStream->Read8( * wxTextInputStreamRead8base0);
// Looking at method wxTextInputStream::Read8S
int  * wxTextInputStreamRead8Sbase0;
wxInt8 retwxTextInputStreamRead8S0 = mywxTextInputStream->Read8S( * wxTextInputStreamRead8Sbase0);
// Looking at method wxTextInputStream::Read16
int  * wxTextInputStreamRead16base0;
wxUint16 retwxTextInputStreamRead160 = mywxTextInputStream->Read16( * wxTextInputStreamRead16base0);
// Looking at method wxTextInputStream::Read16S
int  * wxTextInputStreamRead16Sbase0;
wxInt16 retwxTextInputStreamRead16S0 = mywxTextInputStream->Read16S( * wxTextInputStreamRead16Sbase0);
// Looking at method wxTextInputStream::Read32
int  * wxTextInputStreamRead32base0;
wxUint32 retwxTextInputStreamRead320 = mywxTextInputStream->Read32( * wxTextInputStreamRead32base0);
// Looking at method wxTextInputStream::Read32S
int  * wxTextInputStreamRead32Sbase0;
wxInt32 retwxTextInputStreamRead32S0 = mywxTextInputStream->Read32S( * wxTextInputStreamRead32Sbase0);
// Looking at method wxTextInputStream::GetChar
wxChar retwxTextInputStreamGetChar0 = mywxTextInputStream->GetChar();
// Looking at method wxTextInputStream::ReadDouble
double retwxTextInputStreamReadDouble0 = mywxTextInputStream->ReadDouble();
// Looking at method wxTextInputStream::ReadLine
wxString retwxTextInputStreamReadLine0 = mywxTextInputStream->ReadLine();
// Looking at method wxTextInputStream::ReadString
wxString retwxTextInputStreamReadString0 = mywxTextInputStream->ReadString();
// Looking at method wxTextInputStream::ReadWord
wxString retwxTextInputStreamReadWord0 = mywxTextInputStream->ReadWord();
// Looking at method wxTextInputStream::SetStringSeparators
wxString  * wxTextInputStreamSetStringSeparatorssep0;
mywxTextInputStream->SetStringSeparators( * wxTextInputStreamSetStringSeparatorssep0);

// Looking at class wxTextOutputStream
wxTextOutputStream * mywxTextOutputStream;
// Looking at method wxTextOutputStream::wxTextOutputStream
wxOutputStream  * wxTextOutputStreamwxTextOutputStreamstream0;
wxEOL  * wxTextOutputStreamwxTextOutputStreammode1;
wxTextOutputStream * newwxTextOutputStream0 = new wxTextOutputStream( * wxTextOutputStreamwxTextOutputStreamstream0,  * wxTextOutputStreamwxTextOutputStreammode1);
#if wxUSE_UNICODE == 1
wxOutputStream  * wxTextOutputStreamwxTextOutputStreamstream2;
wxEOL  * wxTextOutputStreamwxTextOutputStreammode3;
wxMBConv  * wxTextOutputStreamwxTextOutputStreamconv4;
wxTextOutputStream * newwxTextOutputStream1 = new wxTextOutputStream( * wxTextOutputStreamwxTextOutputStreamstream2,  * wxTextOutputStreamwxTextOutputStreammode3,  * wxTextOutputStreamwxTextOutputStreamconv4);
#endif //wxUSE_UNICODE
// Looking at method wxTextOutputStream::GetMode
wxEOL retwxTextOutputStreamGetMode0 = mywxTextOutputStream->GetMode();
// Looking at method wxTextOutputStream::PutChar
wxChar  * wxTextOutputStreamPutCharc0;
mywxTextOutputStream->PutChar( * wxTextOutputStreamPutCharc0);
// Looking at method wxTextOutputStream::SetMode
wxEOL  * wxTextOutputStreamSetModemode0;
mywxTextOutputStream->SetMode( * wxTextOutputStreamSetModemode0);
// Looking at method wxTextOutputStream::Write8
wxUint8  * wxTextOutputStreamWrite8i80;
mywxTextOutputStream->Write8( * wxTextOutputStreamWrite8i80);
// Looking at method wxTextOutputStream::Write16
wxUint16  * wxTextOutputStreamWrite16i160;
mywxTextOutputStream->Write16( * wxTextOutputStreamWrite16i160);
// Looking at method wxTextOutputStream::Write32
wxUint32  * wxTextOutputStreamWrite32i320;
mywxTextOutputStream->Write32( * wxTextOutputStreamWrite32i320);
// Looking at method wxTextOutputStream::WriteDouble
// Looking at method wxTextOutputStream::WriteString

// Looking at class wxTextValidator
wxTextValidator * mywxTextValidator;
// Looking at method wxTextValidator::wxTextValidator
wxTextValidator  * wxTextValidatorwxTextValidatorvalidator0;
wxTextValidator * newwxTextValidator0 = new wxTextValidator( * wxTextValidatorwxTextValidatorvalidator0);
long  * wxTextValidatorwxTextValidatorstyle1;
wxString*  * wxTextValidatorwxTextValidatorvalPtr2;
wxTextValidator * newwxTextValidator1 = new wxTextValidator( * wxTextValidatorwxTextValidatorstyle1,  * wxTextValidatorwxTextValidatorvalPtr2);
// Looking at method wxTextValidator::Clone
// Looking at method wxTextValidator::GetExcludes
wxArrayString retwxTextValidatorGetExcludes0 = mywxTextValidator->GetExcludes();
// Looking at method wxTextValidator::GetIncludes
wxArrayString retwxTextValidatorGetIncludes0 = mywxTextValidator->GetIncludes();
// Looking at method wxTextValidator::GetStyle
long retwxTextValidatorGetStyle0 = mywxTextValidator->GetStyle();
// Looking at method wxTextValidator::OnChar
wxKeyEvent  * wxTextValidatorOnCharevent0;
mywxTextValidator->OnChar( * wxTextValidatorOnCharevent0);
// Looking at method wxTextValidator::SetExcludes
wxArrayString  * wxTextValidatorSetExcludesstringList0;
mywxTextValidator->SetExcludes( * wxTextValidatorSetExcludesstringList0);
// Looking at method wxTextValidator::SetIncludes
wxArrayString  * wxTextValidatorSetIncludesstringList0;
mywxTextValidator->SetIncludes( * wxTextValidatorSetIncludesstringList0);
// Looking at method wxTextValidator::SetStyle
long  * wxTextValidatorSetStylestyle0;
mywxTextValidator->SetStyle( * wxTextValidatorSetStylestyle0);
// Looking at method wxTextValidator::TransferFromWindow
// Looking at method wxTextValidator::TransferToWindow
// Looking at method wxTextValidator::Validate

// Looking at class wxTimer
wxTimer * mywxTimer;
// Looking at method wxTimer::wxTimer
wxTimer * newwxTimer0 = new wxTimer();
wxEvtHandler * * wxTimerwxTimerowner0;
int  * wxTimerwxTimerid1;
wxTimer * newwxTimer1 = new wxTimer( * wxTimerwxTimerowner0,  * wxTimerwxTimerid1);
// Looking at method wxTimer::GetInterval
int retwxTimerGetInterval0 = mywxTimer->GetInterval();
// Looking at method wxTimer::IsOneShot
bool retwxTimerIsOneShot0 = mywxTimer->IsOneShot();
// Looking at method wxTimer::IsRunning
bool retwxTimerIsRunning0 = mywxTimer->IsRunning();
// Looking at method wxTimer::Notify
mywxTimer->Notify();
// Looking at method wxTimer::SetOwner
wxEvtHandler * * wxTimerSetOwnerowner0;
int  * wxTimerSetOwnerid1;
mywxTimer->SetOwner( * wxTimerSetOwnerowner0,  * wxTimerSetOwnerid1);
// Looking at method wxTimer::Start
int * wxTimerStartmilliseconds0;
bool  * wxTimerStartoneShot1;
bool retwxTimerStart0 = mywxTimer->Start( * wxTimerStartmilliseconds0,  * wxTimerStartoneShot1);
// Looking at method wxTimer::Stop
mywxTimer->Stop();

// Looking at class wxTimerEvent
wxTimerEvent * mywxTimerEvent;
// Looking at method wxTimerEvent::GetInterval
int retwxTimerEventGetInterval0 = mywxTimerEvent->GetInterval();

// Looking at class wxTipWindow
wxTipWindow * mywxTipWindow;
// Looking at method wxTipWindow::wxTipWindow
wxWindow*  * wxTipWindowwxTipWindowparent0;
wxString  * wxTipWindowwxTipWindowtext1;
wxCoord  * wxTipWindowwxTipWindowmaxLength2;
wxTipWindow**  * wxTipWindowwxTipWindowwindowPtr3;
wxTipWindow * newwxTipWindow0 = new wxTipWindow( * wxTipWindowwxTipWindowparent0,  * wxTipWindowwxTipWindowtext1,  * wxTipWindowwxTipWindowmaxLength2,  * wxTipWindowwxTipWindowwindowPtr3);
// Looking at method wxTipWindow::SetTipWindowPtr
wxTipWindow**  * wxTipWindowSetTipWindowPtrwindowPtr0;
mywxTipWindow->SetTipWindowPtr( * wxTipWindowSetTipWindowPtrwindowPtr0);
// Looking at method wxTipWindow::SetBoundingRect
wxRect  * wxTipWindowSetBoundingRectrectBound0;
mywxTipWindow->SetBoundingRect( * wxTipWindowSetBoundingRectrectBound0);

// Looking at class wxToggleButton
wxToggleButton * mywxToggleButton;
// Looking at method wxToggleButton::wxToggleButton
wxToggleButton * newwxToggleButton0 = new wxToggleButton();
wxWindow*  * wxToggleButtonwxToggleButtonparent0;
wxWindowID  * wxToggleButtonwxToggleButtonid1;
wxString  * wxToggleButtonwxToggleButtonlabel2;
wxPoint  * wxToggleButtonwxToggleButtonpos3;
wxSize  * wxToggleButtonwxToggleButtonsize4;
long  * wxToggleButtonwxToggleButtonstyle5;
wxValidator  * wxToggleButtonwxToggleButtonval6;
wxString  * wxToggleButtonwxToggleButtonname7;
wxToggleButton * newwxToggleButton1 = new wxToggleButton( * wxToggleButtonwxToggleButtonparent0,  * wxToggleButtonwxToggleButtonid1,  * wxToggleButtonwxToggleButtonlabel2,  * wxToggleButtonwxToggleButtonpos3,  * wxToggleButtonwxToggleButtonsize4,  * wxToggleButtonwxToggleButtonstyle5,  * wxToggleButtonwxToggleButtonval6,  * wxToggleButtonwxToggleButtonname7);
// Looking at method wxToggleButton::Create
wxWindow*  * wxToggleButtonCreateparent0;
wxWindowID  * wxToggleButtonCreateid1;
wxString  * wxToggleButtonCreatelabel2;
wxPoint  * wxToggleButtonCreatepos3;
wxSize  * wxToggleButtonCreatesize4;
long  * wxToggleButtonCreatestyle5;
wxValidator  * wxToggleButtonCreateval6;
wxString  * wxToggleButtonCreatename7;
bool retwxToggleButtonCreate0 = mywxToggleButton->Create( * wxToggleButtonCreateparent0,  * wxToggleButtonCreateid1,  * wxToggleButtonCreatelabel2,  * wxToggleButtonCreatepos3,  * wxToggleButtonCreatesize4,  * wxToggleButtonCreatestyle5,  * wxToggleButtonCreateval6,  * wxToggleButtonCreatename7);
// Looking at method wxToggleButton::GetValue
bool retwxToggleButtonGetValue0 = mywxToggleButton->GetValue();
// Looking at method wxToggleButton::SetValue
bool  * wxToggleButtonSetValuestate0;
mywxToggleButton->SetValue( * wxToggleButtonSetValuestate0);

// Looking at class wxToolBar
wxToolBar * mywxToolBar;
// Looking at method wxToolBar::wxToolBar
wxToolBar * newwxToolBar0 = new wxToolBar();
wxWindow*  * wxToolBarwxToolBarparent0;
wxWindowID  * wxToolBarwxToolBarid1;
wxPoint  * wxToolBarwxToolBarpos2;
wxSize  * wxToolBarwxToolBarsize3;
long  * wxToolBarwxToolBarstyle4;
wxString  * wxToolBarwxToolBarname5;
wxToolBar * newwxToolBar1 = new wxToolBar( * wxToolBarwxToolBarparent0,  * wxToolBarwxToolBarid1,  * wxToolBarwxToolBarpos2,  * wxToolBarwxToolBarsize3,  * wxToolBarwxToolBarstyle4,  * wxToolBarwxToolBarname5);
// Looking at method wxToolBar::AddControl
wxControl*  * wxToolBarAddControlcontrol0;
bool retwxToolBarAddControl0 = mywxToolBar->AddControl( * wxToolBarAddControlcontrol0);
// Looking at method wxToolBar::AddSeparator
mywxToolBar->AddSeparator();
// Looking at method wxToolBar::AddTool
int  * wxToolBarAddTooltoolId0;
wxString  * wxToolBarAddToollabel1;
wxBitmap  * wxToolBarAddToolbitmap12;
wxString  * wxToolBarAddToolshortHelpString3;
wxItemKind  * wxToolBarAddToolkind4;
wxToolBarToolBase* retwxToolBarAddTool0 = mywxToolBar->AddTool( * wxToolBarAddTooltoolId0,  * wxToolBarAddToollabel1,  * wxToolBarAddToolbitmap12,  * wxToolBarAddToolshortHelpString3,  * wxToolBarAddToolkind4);
int  * wxToolBarAddTooltoolId5;
wxString  * wxToolBarAddToollabel6;
wxBitmap  * wxToolBarAddToolbitmap17;
wxBitmap  * wxToolBarAddToolbitmap28;
wxItemKind  * wxToolBarAddToolkind9;
wxString  * wxToolBarAddToolshortHelpString10;
wxString  * wxToolBarAddToollongHelpString11;
wxObject*  * wxToolBarAddToolclientData12;
wxToolBarToolBase* retwxToolBarAddTool1 = mywxToolBar->AddTool( * wxToolBarAddTooltoolId5,  * wxToolBarAddToollabel6,  * wxToolBarAddToolbitmap17,  * wxToolBarAddToolbitmap28,  * wxToolBarAddToolkind9,  * wxToolBarAddToolshortHelpString10,  * wxToolBarAddToollongHelpString11,  * wxToolBarAddToolclientData12);
wxToolBarToolBase*  * wxToolBarAddTooltool13;
wxToolBarToolBase* retwxToolBarAddTool2 = mywxToolBar->AddTool( * wxToolBarAddTooltool13);
// Looking at method wxToolBar::AddCheckTool
int  * wxToolBarAddCheckTooltoolId0;
wxString  * wxToolBarAddCheckToollabel1;
wxBitmap  * wxToolBarAddCheckToolbitmap12;
wxBitmap  * wxToolBarAddCheckToolbitmap23;
wxString  * wxToolBarAddCheckToolshortHelpString4;
wxString  * wxToolBarAddCheckToollongHelpString5;
wxObject*  * wxToolBarAddCheckToolclientData6;
wxToolBarToolBase* retwxToolBarAddCheckTool0 = mywxToolBar->AddCheckTool( * wxToolBarAddCheckTooltoolId0,  * wxToolBarAddCheckToollabel1,  * wxToolBarAddCheckToolbitmap12,  * wxToolBarAddCheckToolbitmap23,  * wxToolBarAddCheckToolshortHelpString4,  * wxToolBarAddCheckToollongHelpString5,  * wxToolBarAddCheckToolclientData6);
// Looking at method wxToolBar::AddRadioTool
int  * wxToolBarAddRadioTooltoolId0;
wxString  * wxToolBarAddRadioToollabel1;
wxBitmap  * wxToolBarAddRadioToolbitmap12;
wxBitmap  * wxToolBarAddRadioToolbitmap23;
wxString  * wxToolBarAddRadioToolshortHelpString4;
wxString  * wxToolBarAddRadioToollongHelpString5;
wxObject*  * wxToolBarAddRadioToolclientData6;
wxToolBarToolBase* retwxToolBarAddRadioTool0 = mywxToolBar->AddRadioTool( * wxToolBarAddRadioTooltoolId0,  * wxToolBarAddRadioToollabel1,  * wxToolBarAddRadioToolbitmap12,  * wxToolBarAddRadioToolbitmap23,  * wxToolBarAddRadioToolshortHelpString4,  * wxToolBarAddRadioToollongHelpString5,  * wxToolBarAddRadioToolclientData6);
// Looking at method wxToolBar::DeleteTool
int  * wxToolBarDeleteTooltoolId0;
bool retwxToolBarDeleteTool0 = mywxToolBar->DeleteTool( * wxToolBarDeleteTooltoolId0);
// Looking at method wxToolBar::DeleteToolByPos
size_t  * wxToolBarDeleteToolByPospos0;
bool retwxToolBarDeleteToolByPos0 = mywxToolBar->DeleteToolByPos( * wxToolBarDeleteToolByPospos0);
// Looking at method wxToolBar::EnableTool
int  * wxToolBarEnableTooltoolId0;
bool  * wxToolBarEnableToolenable1;
mywxToolBar->EnableTool( * wxToolBarEnableTooltoolId0,  * wxToolBarEnableToolenable1);
// Looking at method wxToolBar::FindById
int  * wxToolBarFindByIdid0;
wxToolBarToolBase* retwxToolBarFindById0 = mywxToolBar->FindById( * wxToolBarFindByIdid0);
// Looking at method wxToolBar::FindControl
int  * wxToolBarFindControlid0;
wxControl* retwxToolBarFindControl0 = mywxToolBar->FindControl( * wxToolBarFindControlid0);
// Looking at method wxToolBar::FindToolForPosition
float  * wxToolBarFindToolForPositionx0;
float  * wxToolBarFindToolForPositiony1;
wxToolBarToolBase* retwxToolBarFindToolForPosition0 = mywxToolBar->FindToolForPosition( * wxToolBarFindToolForPositionx0,  * wxToolBarFindToolForPositiony1);
// Looking at method wxToolBar::GetToolSize
wxSize retwxToolBarGetToolSize0 = mywxToolBar->GetToolSize();
// Looking at method wxToolBar::GetToolBitmapSize
wxSize retwxToolBarGetToolBitmapSize0 = mywxToolBar->GetToolBitmapSize();
// Looking at method wxToolBar::GetMargins
wxSize retwxToolBarGetMargins0 = mywxToolBar->GetMargins();
// Looking at method wxToolBar::GetToolClientData
int  * wxToolBarGetToolClientDatatoolId0;
wxObject* retwxToolBarGetToolClientData0 = mywxToolBar->GetToolClientData( * wxToolBarGetToolClientDatatoolId0);
// Looking at method wxToolBar::GetToolEnabled
int  * wxToolBarGetToolEnabledtoolId0;
bool retwxToolBarGetToolEnabled0 = mywxToolBar->GetToolEnabled( * wxToolBarGetToolEnabledtoolId0);
// Looking at method wxToolBar::GetToolLongHelp
int  * wxToolBarGetToolLongHelptoolId0;
wxString retwxToolBarGetToolLongHelp0 = mywxToolBar->GetToolLongHelp( * wxToolBarGetToolLongHelptoolId0);
// Looking at method wxToolBar::GetToolPacking
int retwxToolBarGetToolPacking0 = mywxToolBar->GetToolPacking();
// Looking at method wxToolBar::GetToolPos
int  * wxToolBarGetToolPostoolId0;
int retwxToolBarGetToolPos0 = mywxToolBar->GetToolPos( * wxToolBarGetToolPostoolId0);
// Looking at method wxToolBar::GetToolSeparation
int retwxToolBarGetToolSeparation0 = mywxToolBar->GetToolSeparation();
// Looking at method wxToolBar::GetToolShortHelp
int  * wxToolBarGetToolShortHelptoolId0;
wxString retwxToolBarGetToolShortHelp0 = mywxToolBar->GetToolShortHelp( * wxToolBarGetToolShortHelptoolId0);
// Looking at method wxToolBar::GetToolState
int  * wxToolBarGetToolStatetoolId0;
bool retwxToolBarGetToolState0 = mywxToolBar->GetToolState( * wxToolBarGetToolStatetoolId0);
// Looking at method wxToolBar::InsertControl
size_t  * wxToolBarInsertControlpos0;
wxControl * * wxToolBarInsertControlcontrol1;
wxToolBarToolBase * retwxToolBarInsertControl0 = mywxToolBar->InsertControl( * wxToolBarInsertControlpos0,  * wxToolBarInsertControlcontrol1);
// Looking at method wxToolBar::InsertSeparator
size_t  * wxToolBarInsertSeparatorpos0;
wxToolBarToolBase * retwxToolBarInsertSeparator0 = mywxToolBar->InsertSeparator( * wxToolBarInsertSeparatorpos0);
// Looking at method wxToolBar::InsertTool
size_t  * wxToolBarInsertToolpos0;
int  * wxToolBarInsertTooltoolId1;
wxBitmap  * wxToolBarInsertToolbitmap12;
wxBitmap  * wxToolBarInsertToolbitmap23;
bool  * wxToolBarInsertToolisToggle4;
wxObject*  * wxToolBarInsertToolclientData5;
wxString  * wxToolBarInsertToolshortHelpString6;
wxString  * wxToolBarInsertToollongHelpString7;
wxToolBarToolBase * retwxToolBarInsertTool0 = mywxToolBar->InsertTool( * wxToolBarInsertToolpos0,  * wxToolBarInsertTooltoolId1,  * wxToolBarInsertToolbitmap12,  * wxToolBarInsertToolbitmap23,  * wxToolBarInsertToolisToggle4,  * wxToolBarInsertToolclientData5,  * wxToolBarInsertToolshortHelpString6,  * wxToolBarInsertToollongHelpString7);
size_t  * wxToolBarInsertToolpos8;
wxToolBarToolBase*  * wxToolBarInsertTooltool9;
wxToolBarToolBase * retwxToolBarInsertTool1 = mywxToolBar->InsertTool( * wxToolBarInsertToolpos8,  * wxToolBarInsertTooltool9);
// Looking at method wxToolBar::OnLeftClick
int  * wxToolBarOnLeftClicktoolId0;
bool  * wxToolBarOnLeftClicktoggleDown1;
bool retwxToolBarOnLeftClick0 = mywxToolBar->OnLeftClick( * wxToolBarOnLeftClicktoolId0,  * wxToolBarOnLeftClicktoggleDown1);
// Looking at method wxToolBar::OnMouseEnter
int  * wxToolBarOnMouseEntertoolId0;
mywxToolBar->OnMouseEnter( * wxToolBarOnMouseEntertoolId0);
// Looking at method wxToolBar::OnRightClick
int  * wxToolBarOnRightClicktoolId0;
float  * wxToolBarOnRightClickx1;
float  * wxToolBarOnRightClicky2;
mywxToolBar->OnRightClick( * wxToolBarOnRightClicktoolId0,  * wxToolBarOnRightClickx1,  * wxToolBarOnRightClicky2);
// Looking at method wxToolBar::Realize
bool retwxToolBarRealize0 = mywxToolBar->Realize();
// Looking at method wxToolBar::RemoveTool
int  * wxToolBarRemoveToolid0;
wxToolBarToolBase * retwxToolBarRemoveTool0 = mywxToolBar->RemoveTool( * wxToolBarRemoveToolid0);
// Looking at method wxToolBar::SetMargins
wxSize  * wxToolBarSetMarginssize0;
mywxToolBar->SetMargins( * wxToolBarSetMarginssize0);
int  * wxToolBarSetMarginsx1;
int  * wxToolBarSetMarginsy2;
mywxToolBar->SetMargins( * wxToolBarSetMarginsx1,  * wxToolBarSetMarginsy2);
// Looking at method wxToolBar::SetToolBitmapSize
wxSize  * wxToolBarSetToolBitmapSizesize0;
mywxToolBar->SetToolBitmapSize( * wxToolBarSetToolBitmapSizesize0);
// Looking at method wxToolBar::SetToolClientData
int  * wxToolBarSetToolClientDataid0;
wxObject*  * wxToolBarSetToolClientDataclientData1;
mywxToolBar->SetToolClientData( * wxToolBarSetToolClientDataid0,  * wxToolBarSetToolClientDataclientData1);
// Looking at method wxToolBar::SetToolLongHelp
int  * wxToolBarSetToolLongHelptoolId0;
wxString  * wxToolBarSetToolLongHelphelpString1;
mywxToolBar->SetToolLongHelp( * wxToolBarSetToolLongHelptoolId0,  * wxToolBarSetToolLongHelphelpString1);
// Looking at method wxToolBar::SetToolPacking
int  * wxToolBarSetToolPackingpacking0;
mywxToolBar->SetToolPacking( * wxToolBarSetToolPackingpacking0);
// Looking at method wxToolBar::SetToolShortHelp
int  * wxToolBarSetToolShortHelptoolId0;
wxString  * wxToolBarSetToolShortHelphelpString1;
mywxToolBar->SetToolShortHelp( * wxToolBarSetToolShortHelptoolId0,  * wxToolBarSetToolShortHelphelpString1);
// Looking at method wxToolBar::SetToolSeparation
int  * wxToolBarSetToolSeparationseparation0;
mywxToolBar->SetToolSeparation( * wxToolBarSetToolSeparationseparation0);
// Looking at method wxToolBar::ToggleTool
int  * wxToolBarToggleTooltoolId0;
bool  * wxToolBarToggleTooltoggle1;
mywxToolBar->ToggleTool( * wxToolBarToggleTooltoolId0,  * wxToolBarToggleTooltoggle1);

// Looking at class wxToolTip
wxToolTip * mywxToolTip;
// Looking at method wxToolTip::Enable
bool  * wxToolTipEnableflag0;
mywxToolTip->Enable( * wxToolTipEnableflag0);
// Looking at method wxToolTip::SetDelay
long  * wxToolTipSetDelaymsecs0;
mywxToolTip->SetDelay( * wxToolTipSetDelaymsecs0);
// Looking at method wxToolTip::wxToolTip
wxString  * wxToolTipwxToolTiptip0;
wxToolTip * newwxToolTip0 = new wxToolTip( * wxToolTipwxToolTiptip0);
// Looking at method wxToolTip::SetTip
wxString  * wxToolTipSetTiptip0;
mywxToolTip->SetTip( * wxToolTipSetTiptip0);
// Looking at method wxToolTip::GetTip
wxString retwxToolTipGetTip0 = mywxToolTip->GetTip();
// Looking at method wxToolTip::GetWindow
wxWindow* retwxToolTipGetWindow0 = mywxToolTip->GetWindow();

// Looking at class wxTopLevelWindow
wxTopLevelWindow * mywxTopLevelWindow;
// Looking at method wxTopLevelWindow::GetIcon
const wxIcon retwxTopLevelWindowGetIcon0 = mywxTopLevelWindow->GetIcon();
// Looking at method wxTopLevelWindow::GetIcons
const wxIconBundle retwxTopLevelWindowGetIcons0 = mywxTopLevelWindow->GetIcons();
// Looking at method wxTopLevelWindow::GetTitle
wxString retwxTopLevelWindowGetTitle0 = mywxTopLevelWindow->GetTitle();
// Looking at method wxTopLevelWindow::IsActive
bool retwxTopLevelWindowIsActive0 = mywxTopLevelWindow->IsActive();
// Looking at method wxTopLevelWindow::Iconize
bool  * wxTopLevelWindowIconizeiconize0;
mywxTopLevelWindow->Iconize( * wxTopLevelWindowIconizeiconize0);
// Looking at method wxTopLevelWindow::IsFullScreen
bool retwxTopLevelWindowIsFullScreen0 = mywxTopLevelWindow->IsFullScreen();
// Looking at method wxTopLevelWindow::IsIconized
bool retwxTopLevelWindowIsIconized0 = mywxTopLevelWindow->IsIconized();
// Looking at method wxTopLevelWindow::IsMaximized
bool retwxTopLevelWindowIsMaximized0 = mywxTopLevelWindow->IsMaximized();
// Looking at method wxTopLevelWindow::Maximize
bool  * wxTopLevelWindowMaximizemaximize0;
mywxTopLevelWindow->Maximize( * wxTopLevelWindowMaximizemaximize0);
// Looking at method wxTopLevelWindow::RequestUserAttention
int  * wxTopLevelWindowRequestUserAttentionflags0;
mywxTopLevelWindow->RequestUserAttention( * wxTopLevelWindowRequestUserAttentionflags0);
// Looking at method wxTopLevelWindow::SetIcon
wxIcon  * wxTopLevelWindowSetIconicon0;
mywxTopLevelWindow->SetIcon( * wxTopLevelWindowSetIconicon0);
// Looking at method wxTopLevelWindow::SetIcons
wxIconBundle  * wxTopLevelWindowSetIconsicons0;
mywxTopLevelWindow->SetIcons( * wxTopLevelWindowSetIconsicons0);
// Looking at method wxTopLevelWindow::SetShape
wxRegion  * wxTopLevelWindowSetShaperegion0;
bool retwxTopLevelWindowSetShape0 = mywxTopLevelWindow->SetShape( * wxTopLevelWindowSetShaperegion0);
// Looking at method wxTopLevelWindow::SetTitle
// Looking at method wxTopLevelWindow::ShowFullScreen
bool  * wxTopLevelWindowShowFullScreenshow0;
long  * wxTopLevelWindowShowFullScreenstyle1;
bool retwxTopLevelWindowShowFullScreen0 = mywxTopLevelWindow->ShowFullScreen( * wxTopLevelWindowShowFullScreenshow0,  * wxTopLevelWindowShowFullScreenstyle1);

// Looking at class wxTreeEvent
wxTreeEvent * mywxTreeEvent;
// Looking at method wxTreeEvent::wxTreeEvent
WXTYPE  * wxTreeEventwxTreeEventcommandType0;
int  * wxTreeEventwxTreeEventid1;
wxTreeEvent * newwxTreeEvent0 = new wxTreeEvent( * wxTreeEventwxTreeEventcommandType0,  * wxTreeEventwxTreeEventid1);
// Looking at method wxTreeEvent::GetKeyCode
int retwxTreeEventGetKeyCode0 = mywxTreeEvent->GetKeyCode();
// Looking at method wxTreeEvent::GetItem
wxTreeItemId retwxTreeEventGetItem0 = mywxTreeEvent->GetItem();
// Looking at method wxTreeEvent::GetKeyEvent
const wxKeyEvent retwxTreeEventGetKeyEvent0 = mywxTreeEvent->GetKeyEvent();
// Looking at method wxTreeEvent::GetLabel
const wxString retwxTreeEventGetLabel0 = mywxTreeEvent->GetLabel();
// Looking at method wxTreeEvent::GetOldItem
wxTreeItemId retwxTreeEventGetOldItem0 = mywxTreeEvent->GetOldItem();
// Looking at method wxTreeEvent::GetPoint
wxPoint retwxTreeEventGetPoint0 = mywxTreeEvent->GetPoint();
// Looking at method wxTreeEvent::IsEditCancelled
bool retwxTreeEventIsEditCancelled0 = mywxTreeEvent->IsEditCancelled();
// Looking at method wxTreeEvent::SetToolTip
wxString  * wxTreeEventSetToolTiptooltip0;
mywxTreeEvent->SetToolTip( * wxTreeEventSetToolTiptooltip0);

// Looking at class wxTreeItemData
wxTreeItemData * mywxTreeItemData;
// Looking at method wxTreeItemData::wxTreeItemData
wxTreeItemData * newwxTreeItemData0 = new wxTreeItemData();
// Looking at method wxTreeItemData::GetId
const wxTreeItemId retwxTreeItemDataGetId0 = mywxTreeItemData->GetId();
// Looking at method wxTreeItemData::SetId
wxTreeItemId  * wxTreeItemDataSetIdid0;
mywxTreeItemData->SetId( * wxTreeItemDataSetIdid0);

// Looking at class wxURI
wxURI * mywxURI;
// Looking at method wxURI::
// Looking at method wxURI::wxURI
wxURI * newwxURI0 = new wxURI();
wxChar*  * wxURIwxURIuri0;
wxURI * newwxURI1 = new wxURI( * wxURIwxURIuri0);
wxURI  * wxURIwxURIuri1;
wxURI * newwxURI2 = new wxURI( * wxURIwxURIuri1);
// Looking at method wxURI::BuildURI
wxString retwxURIBuildURI0 = mywxURI->BuildURI();
// Looking at method wxURI::BuildUnescapedURI
wxString retwxURIBuildUnescapedURI0 = mywxURI->BuildUnescapedURI();
// Looking at method wxURI::Create
wxChar*  * wxURICreateuri0;
const wxChar* retwxURICreate0 = mywxURI->Create( * wxURICreateuri0);
// Looking at method wxURI::GetFragment
const wxString retwxURIGetFragment0 = mywxURI->GetFragment();
// Looking at method wxURI::GetHostType
const HostType retwxURIGetHostType0 = mywxURI->GetHostType();
// Looking at method wxURI::GetPath
const wxString retwxURIGetPath0 = mywxURI->GetPath();
// Looking at method wxURI::GetPort
const wxString retwxURIGetPort0 = mywxURI->GetPort();
// Looking at method wxURI::GetQuery
const wxString retwxURIGetQuery0 = mywxURI->GetQuery();
// Looking at method wxURI::GetScheme
const wxString retwxURIGetScheme0 = mywxURI->GetScheme();
// Looking at method wxURI::GetServer
const wxString retwxURIGetServer0 = mywxURI->GetServer();
// Looking at method wxURI::GetUser
const wxString retwxURIGetUser0 = mywxURI->GetUser();
// Looking at method wxURI::HasFragment
bool retwxURIHasFragment0 = mywxURI->HasFragment();
// Looking at method wxURI::HasPath
bool retwxURIHasPath0 = mywxURI->HasPath();
// Looking at method wxURI::HasPort
bool retwxURIHasPort0 = mywxURI->HasPort();
// Looking at method wxURI::HasQuery
bool retwxURIHasQuery0 = mywxURI->HasQuery();
// Looking at method wxURI::HasScheme
bool retwxURIHasScheme0 = mywxURI->HasScheme();
// Looking at method wxURI::HasServer
bool retwxURIHasServer0 = mywxURI->HasServer();
// Looking at method wxURI::HasUser
bool retwxURIHasUser0 = mywxURI->HasUser();
// Looking at method wxURI::IsReference
bool retwxURIIsReference0 = mywxURI->IsReference();
// Looking at method wxURI::Resolve
wxURI  * wxURIResolvebase0;
int  * wxURIResolveflags1;
mywxURI->Resolve( * wxURIResolvebase0,  * wxURIResolveflags1);
// Looking at method wxURI::Unescape
wxString  * wxURIUnescapeuri0;
wxString retwxURIUnescape0 = mywxURI->Unescape( * wxURIUnescapeuri0);

// Looking at class wxUpdateUIEvent
wxUpdateUIEvent * mywxUpdateUIEvent;
// Looking at method wxUpdateUIEvent::wxUpdateUIEvent
wxWindowID  * wxUpdateUIEventwxUpdateUIEventcommandId0;
wxUpdateUIEvent * newwxUpdateUIEvent0 = new wxUpdateUIEvent( * wxUpdateUIEventwxUpdateUIEventcommandId0);
// Looking at method wxUpdateUIEvent::CanUpdate
wxWindow*  * wxUpdateUIEventCanUpdatewindow0;
static bool retwxUpdateUIEventCanUpdate0 = mywxUpdateUIEvent->CanUpdate( * wxUpdateUIEventCanUpdatewindow0);
// Looking at method wxUpdateUIEvent::Check
bool  * wxUpdateUIEventCheckcheck0;
mywxUpdateUIEvent->Check( * wxUpdateUIEventCheckcheck0);
// Looking at method wxUpdateUIEvent::Enable
bool  * wxUpdateUIEventEnableenable0;
mywxUpdateUIEvent->Enable( * wxUpdateUIEventEnableenable0);
// Looking at method wxUpdateUIEvent::GetChecked
bool retwxUpdateUIEventGetChecked0 = mywxUpdateUIEvent->GetChecked();
// Looking at method wxUpdateUIEvent::GetEnabled
bool retwxUpdateUIEventGetEnabled0 = mywxUpdateUIEvent->GetEnabled();
// Looking at method wxUpdateUIEvent::GetSetChecked
bool retwxUpdateUIEventGetSetChecked0 = mywxUpdateUIEvent->GetSetChecked();
// Looking at method wxUpdateUIEvent::GetSetEnabled
bool retwxUpdateUIEventGetSetEnabled0 = mywxUpdateUIEvent->GetSetEnabled();
// Looking at method wxUpdateUIEvent::GetSetText
bool retwxUpdateUIEventGetSetText0 = mywxUpdateUIEvent->GetSetText();
// Looking at method wxUpdateUIEvent::GetText
wxString retwxUpdateUIEventGetText0 = mywxUpdateUIEvent->GetText();
// Looking at method wxUpdateUIEvent::GetMode
static wxUpdateUIMode retwxUpdateUIEventGetMode0 = mywxUpdateUIEvent->GetMode();
// Looking at method wxUpdateUIEvent::GetUpdateInterval
static long retwxUpdateUIEventGetUpdateInterval0 = mywxUpdateUIEvent->GetUpdateInterval();
// Looking at method wxUpdateUIEvent::ResetUpdateTime
mywxUpdateUIEvent->ResetUpdateTime();
// Looking at method wxUpdateUIEvent::SetMode
wxUpdateUIMode  * wxUpdateUIEventSetModemode0;
mywxUpdateUIEvent->SetMode( * wxUpdateUIEventSetModemode0);
// Looking at method wxUpdateUIEvent::SetText
wxString  * wxUpdateUIEventSetTexttext0;
mywxUpdateUIEvent->SetText( * wxUpdateUIEventSetTexttext0);
// Looking at method wxUpdateUIEvent::SetUpdateInterval
long  * wxUpdateUIEventSetUpdateIntervalupdateInterval0;
mywxUpdateUIEvent->SetUpdateInterval( * wxUpdateUIEventSetUpdateIntervalupdateInterval0);

// Looking at class wxValidator
wxValidator * mywxValidator;
// Looking at method wxValidator::wxValidator
wxValidator * newwxValidator0 = new wxValidator();
// Looking at method wxValidator::Clone
// Looking at method wxValidator::GetWindow
wxWindow* retwxValidatorGetWindow0 = mywxValidator->GetWindow();
// Looking at method wxValidator::SetBellOnError
bool  * wxValidatorSetBellOnErrordoIt0;
mywxValidator->SetBellOnError( * wxValidatorSetBellOnErrordoIt0);
// Looking at method wxValidator::SetWindow
wxWindow*  * wxValidatorSetWindowwindow0;
mywxValidator->SetWindow( * wxValidatorSetWindowwindow0);
// Looking at method wxValidator::TransferFromWindow
// Looking at method wxValidator::TransferToWindow
// Looking at method wxValidator::Validate

// Looking at class wxVariant
wxVariant * mywxVariant;
// Looking at method wxVariant::wxVariant
wxVariant * newwxVariant0 = new wxVariant();
wxVariant  * wxVariantwxVariantvariant0;
wxVariant * newwxVariant1 = new wxVariant( * wxVariantwxVariantvariant0);
char*  * wxVariantwxVariantvalue1;
wxString  * wxVariantwxVariantname2;
wxVariant * newwxVariant2 = new wxVariant( * wxVariantwxVariantvalue1,  * wxVariantwxVariantname2);
wxString  * wxVariantwxVariantvalue3;
wxString  * wxVariantwxVariantname4;
wxVariant * newwxVariant3 = new wxVariant( * wxVariantwxVariantvalue3,  * wxVariantwxVariantname4);
char  * wxVariantwxVariantvalue5;
wxString  * wxVariantwxVariantname6;
wxVariant * newwxVariant4 = new wxVariant( * wxVariantwxVariantvalue5,  * wxVariantwxVariantname6);
long  * wxVariantwxVariantvalue7;
wxString  * wxVariantwxVariantname8;
wxVariant * newwxVariant5 = new wxVariant( * wxVariantwxVariantvalue7,  * wxVariantwxVariantname8);
bool  * wxVariantwxVariantvalue9;
wxString  * wxVariantwxVariantname10;
wxVariant * newwxVariant6 = new wxVariant( * wxVariantwxVariantvalue9,  * wxVariantwxVariantname10);
double  * wxVariantwxVariantvalue11;
wxString  * wxVariantwxVariantname12;
wxVariant * newwxVariant7 = new wxVariant( * wxVariantwxVariantvalue11,  * wxVariantwxVariantname12);
wxList  * wxVariantwxVariantvalue13;
wxString  * wxVariantwxVariantname14;
wxVariant * newwxVariant8 = new wxVariant( * wxVariantwxVariantvalue13,  * wxVariantwxVariantname14);
void*  * wxVariantwxVariantvalue15;
wxString  * wxVariantwxVariantname16;
wxVariant * newwxVariant9 = new wxVariant( * wxVariantwxVariantvalue15,  * wxVariantwxVariantname16);
wxObject*  * wxVariantwxVariantvalue17;
wxString  * wxVariantwxVariantname18;
wxVariant * newwxVariant10 = new wxVariant( * wxVariantwxVariantvalue17,  * wxVariantwxVariantname18);
wxVariantData*  * wxVariantwxVariantdata19;
wxString  * wxVariantwxVariantname20;
wxVariant * newwxVariant11 = new wxVariant( * wxVariantwxVariantdata19,  * wxVariantwxVariantname20);
wxDateTime  * wxVariantwxVariantval21;
wxString  * wxVariantwxVariantname22;
wxVariant * newwxVariant12 = new wxVariant( * wxVariantwxVariantval21,  * wxVariantwxVariantname22);
wxArrayString  * wxVariantwxVariantval23;
wxString  * wxVariantwxVariantname24;
wxVariant * newwxVariant13 = new wxVariant( * wxVariantwxVariantval23,  * wxVariantwxVariantname24);
#if wxUSE_ODBC == 1
DATE_STRUCT*  * wxVariantwxVariantval25;
wxString  * wxVariantwxVariantname26;
wxVariant * newwxVariant14 = new wxVariant( * wxVariantwxVariantval25,  * wxVariantwxVariantname26);
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1
TIME_STRUCT*  * wxVariantwxVariantval27;
wxString  * wxVariantwxVariantname28;
wxVariant * newwxVariant15 = new wxVariant( * wxVariantwxVariantval27,  * wxVariantwxVariantname28);
#endif //wxUSE_ODBC
#if wxUSE_ODBC == 1
TIMESTAMP_STRUCT*  * wxVariantwxVariantval29;
wxString  * wxVariantwxVariantname30;
wxVariant * newwxVariant16 = new wxVariant( * wxVariantwxVariantval29,  * wxVariantwxVariantname30);
#endif //wxUSE_ODBC
// Looking at method wxVariant::Append
wxVariant  * wxVariantAppendvalue0;
mywxVariant->Append( * wxVariantAppendvalue0);
// Looking at method wxVariant::ClearList
mywxVariant->ClearList();
// Looking at method wxVariant::Convert
long*  * wxVariantConvertvalue0;
bool retwxVariantConvert0 = mywxVariant->Convert( * wxVariantConvertvalue0);
bool*  * wxVariantConvertvalue1;
bool retwxVariantConvert1 = mywxVariant->Convert( * wxVariantConvertvalue1);
double*  * wxVariantConvertvalue2;
bool retwxVariantConvert2 = mywxVariant->Convert( * wxVariantConvertvalue2);
wxString*  * wxVariantConvertvalue3;
bool retwxVariantConvert3 = mywxVariant->Convert( * wxVariantConvertvalue3);
char*  * wxVariantConvertvalue4;
bool retwxVariantConvert4 = mywxVariant->Convert( * wxVariantConvertvalue4);
wxDateTime*  * wxVariantConvertvalue5;
bool retwxVariantConvert5 = mywxVariant->Convert( * wxVariantConvertvalue5);
// Looking at method wxVariant::GetCount
int retwxVariantGetCount0 = mywxVariant->GetCount();
// Looking at method wxVariant::Delete
int  * wxVariantDeleteitem0;
bool retwxVariantDelete0 = mywxVariant->Delete( * wxVariantDeleteitem0);
// Looking at method wxVariant::GetArrayString
wxArrayString retwxVariantGetArrayString0 = mywxVariant->GetArrayString();
// Looking at method wxVariant::GetBool
bool retwxVariantGetBool0 = mywxVariant->GetBool();
// Looking at method wxVariant::GetChar
char retwxVariantGetChar0 = mywxVariant->GetChar();
// Looking at method wxVariant::GetData
wxVariantData* retwxVariantGetData0 = mywxVariant->GetData();
// Looking at method wxVariant::GetDateTime
wxDateTime retwxVariantGetDateTime0 = mywxVariant->GetDateTime();
// Looking at method wxVariant::GetDouble
double retwxVariantGetDouble0 = mywxVariant->GetDouble();
// Looking at method wxVariant::GetLong
long retwxVariantGetLong0 = mywxVariant->GetLong();
// Looking at method wxVariant::GetName
const wxString retwxVariantGetName0 = mywxVariant->GetName();
// Looking at method wxVariant::GetString
wxString retwxVariantGetString0 = mywxVariant->GetString();
// Looking at method wxVariant::GetType
wxString retwxVariantGetType0 = mywxVariant->GetType();
// Looking at method wxVariant::GetVoidPtr
mywxVariant->GetVoidPtr();
// Looking at method wxVariant::GetWxObjectPtr
mywxVariant->GetWxObjectPtr();
// Looking at method wxVariant::Insert
wxVariant  * wxVariantInsertvalue0;
mywxVariant->Insert( * wxVariantInsertvalue0);
// Looking at method wxVariant::IsNull
bool retwxVariantIsNull0 = mywxVariant->IsNull();
// Looking at method wxVariant::IsType
wxString  * wxVariantIsTypetype0;
bool retwxVariantIsType0 = mywxVariant->IsType( * wxVariantIsTypetype0);
// Looking at method wxVariant::IsValueKindOf
wxClassInfo*   * wxVariantIsValueKindOftype0;
bool retwxVariantIsValueKindOf0 = mywxVariant->IsValueKindOf( * wxVariantIsValueKindOftype0);
// Looking at method wxVariant::MakeNull
mywxVariant->MakeNull();
// Looking at method wxVariant::MakeString
wxString retwxVariantMakeString0 = mywxVariant->MakeString();
// Looking at method wxVariant::Member
wxVariant  * wxVariantMembervalue0;
bool retwxVariantMember0 = mywxVariant->Member( * wxVariantMembervalue0);
// Looking at method wxVariant::NullList
mywxVariant->NullList();
// Looking at method wxVariant::SetData
wxVariantData*  * wxVariantSetDatadata0;
mywxVariant->SetData( * wxVariantSetDatadata0);

// Looking at class wxWindow
wxWindow * mywxWindow;
// Looking at method wxWindow::wxWindow
wxWindow * newwxWindow0 = new wxWindow();
wxWindow*  * wxWindowwxWindowparent0;
wxWindowID  * wxWindowwxWindowid1;
wxPoint  * wxWindowwxWindowpos2;
wxSize  * wxWindowwxWindowsize3;
long  * wxWindowwxWindowstyle4;
wxString  * wxWindowwxWindowname5;
wxWindow * newwxWindow1 = new wxWindow( * wxWindowwxWindowparent0,  * wxWindowwxWindowid1,  * wxWindowwxWindowpos2,  * wxWindowwxWindowsize3,  * wxWindowwxWindowstyle4,  * wxWindowwxWindowname5);
// Looking at method wxWindow::AddChild
// Looking at method wxWindow::CacheBestSize
wxSize  * wxWindowCacheBestSizesize0;
mywxWindow->CacheBestSize( * wxWindowCacheBestSizesize0);
// Looking at method wxWindow::CaptureMouse
// Looking at method wxWindow::Center
int  * wxWindowCenterdirection0;
mywxWindow->Center( * wxWindowCenterdirection0);
// Looking at method wxWindow::CenterOnParent
int  * wxWindowCenterOnParentdirection0;
mywxWindow->CenterOnParent( * wxWindowCenterOnParentdirection0);
// Looking at method wxWindow::CenterOnScreen
int  * wxWindowCenterOnScreendirection0;
mywxWindow->CenterOnScreen( * wxWindowCenterOnScreendirection0);
// Looking at method wxWindow::Centre
int  * wxWindowCentredirection0;
mywxWindow->Centre( * wxWindowCentredirection0);
// Looking at method wxWindow::CentreOnParent
int  * wxWindowCentreOnParentdirection0;
mywxWindow->CentreOnParent( * wxWindowCentreOnParentdirection0);
// Looking at method wxWindow::CentreOnScreen
int  * wxWindowCentreOnScreendirection0;
mywxWindow->CentreOnScreen( * wxWindowCentreOnScreendirection0);
// Looking at method wxWindow::ClearBackground
mywxWindow->ClearBackground();
// Looking at method wxWindow::ClientToScreen
// Looking at method wxWindow::Close
bool  * wxWindowCloseforce0;
bool retwxWindowClose0 = mywxWindow->Close( * wxWindowCloseforce0);
// Looking at method wxWindow::ConvertDialogToPixels
wxPoint  * wxWindowConvertDialogToPixelspt0;
wxPoint retwxWindowConvertDialogToPixels0 = mywxWindow->ConvertDialogToPixels( * wxWindowConvertDialogToPixelspt0);
wxSize  * wxWindowConvertDialogToPixelssz1;
wxSize retwxWindowConvertDialogToPixels1 = mywxWindow->ConvertDialogToPixels( * wxWindowConvertDialogToPixelssz1);
// Looking at method wxWindow::ConvertPixelsToDialog
wxPoint  * wxWindowConvertPixelsToDialogpt0;
wxPoint retwxWindowConvertPixelsToDialog0 = mywxWindow->ConvertPixelsToDialog( * wxWindowConvertPixelsToDialogpt0);
wxSize  * wxWindowConvertPixelsToDialogsz1;
wxSize retwxWindowConvertPixelsToDialog1 = mywxWindow->ConvertPixelsToDialog( * wxWindowConvertPixelsToDialogsz1);
// Looking at method wxWindow::Destroy
// Looking at method wxWindow::DestroyChildren
// Looking at method wxWindow::Disable
bool retwxWindowDisable0 = mywxWindow->Disable();
// Looking at method wxWindow::DoGetBestSize
// Looking at method wxWindow::DoUpdateWindowUI
// Looking at method wxWindow::DragAcceptFiles
// Looking at method wxWindow::Enable
// Looking at method wxWindow::FindFocus
static wxWindow* retwxWindowFindFocus0 = mywxWindow->FindFocus();
// Looking at method wxWindow::FindWindow
long  * wxWindowFindWindowid0;
wxWindow* retwxWindowFindWindow0 = mywxWindow->FindWindow( * wxWindowFindWindowid0);
wxString  * wxWindowFindWindowname1;
wxWindow* retwxWindowFindWindow1 = mywxWindow->FindWindow( * wxWindowFindWindowname1);
// Looking at method wxWindow::FindWindowById
long  * wxWindowFindWindowByIdid0;
wxWindow*  * wxWindowFindWindowByIdparent1;
static wxWindow* retwxWindowFindWindowById0 = mywxWindow->FindWindowById( * wxWindowFindWindowByIdid0,  * wxWindowFindWindowByIdparent1);
// Looking at method wxWindow::FindWindowByName
wxString  * wxWindowFindWindowByNamename0;
wxWindow*  * wxWindowFindWindowByNameparent1;
static wxWindow* retwxWindowFindWindowByName0 = mywxWindow->FindWindowByName( * wxWindowFindWindowByNamename0,  * wxWindowFindWindowByNameparent1);
// Looking at method wxWindow::FindWindowByLabel
wxString  * wxWindowFindWindowByLabellabel0;
wxWindow*  * wxWindowFindWindowByLabelparent1;
static wxWindow* retwxWindowFindWindowByLabel0 = mywxWindow->FindWindowByLabel( * wxWindowFindWindowByLabellabel0,  * wxWindowFindWindowByLabelparent1);
// Looking at method wxWindow::Fit
// Looking at method wxWindow::FitInside
// Looking at method wxWindow::Freeze
// Looking at method wxWindow::GetAcceleratorTable
wxAcceleratorTable* retwxWindowGetAcceleratorTable0 = mywxWindow->GetAcceleratorTable();
// Looking at method wxWindow::GetAccessible
#if wxUSE_ACCESSIBILITY == 1
wxAccessible* retwxWindowGetAccessible0 = mywxWindow->GetAccessible();
#endif //wxUSE_ACCESSIBILITY
// Looking at method wxWindow::GetAdjustedBestSize
wxSize retwxWindowGetAdjustedBestSize0 = mywxWindow->GetAdjustedBestSize();
// Looking at method wxWindow::GetBackgroundColour
// Looking at method wxWindow::GetBackgroundStyle
// Looking at method wxWindow::GetBestFittingSize
wxSize retwxWindowGetBestFittingSize0 = mywxWindow->GetBestFittingSize();
// Looking at method wxWindow::GetBestSize
wxSize retwxWindowGetBestSize0 = mywxWindow->GetBestSize();
// Looking at method wxWindow::GetCaret
wxCaret * retwxWindowGetCaret0 = mywxWindow->GetCaret();
// Looking at method wxWindow::GetCapture
static wxWindow * retwxWindowGetCapture0 = mywxWindow->GetCapture();
// Looking at method wxWindow::GetCharHeight
// Looking at method wxWindow::GetCharWidth
// Looking at method wxWindow::GetChildren
wxList retwxWindowGetChildren0 = mywxWindow->GetChildren();
// Looking at method wxWindow::GetClassDefaultAttributes
wxWindowVariant  * wxWindowGetClassDefaultAttributesvariant0;
static wxVisualAttributes retwxWindowGetClassDefaultAttributes0 = mywxWindow->GetClassDefaultAttributes( * wxWindowGetClassDefaultAttributesvariant0);
// Looking at method wxWindow::GetClientSize
int*  * wxWindowGetClientSizewidth0;
int*  * wxWindowGetClientSizeheight1;
mywxWindow->GetClientSize( * wxWindowGetClientSizewidth0,  * wxWindowGetClientSizeheight1);
wxSize retwxWindowGetClientSize1 = mywxWindow->GetClientSize();
// Looking at method wxWindow::GetConstraints
wxLayoutConstraints* retwxWindowGetConstraints0 = mywxWindow->GetConstraints();
// Looking at method wxWindow::GetContainingSizer
const wxSizer * retwxWindowGetContainingSizer0 = mywxWindow->GetContainingSizer();
// Looking at method wxWindow::GetCursor
const wxCursor retwxWindowGetCursor0 = mywxWindow->GetCursor();
// Looking at method wxWindow::GetDefaultAttributes
// Looking at method wxWindow::GetDropTarget
wxDropTarget* retwxWindowGetDropTarget0 = mywxWindow->GetDropTarget();
// Looking at method wxWindow::GetEventHandler
wxEvtHandler* retwxWindowGetEventHandler0 = mywxWindow->GetEventHandler();
// Looking at method wxWindow::GetExtraStyle
long retwxWindowGetExtraStyle0 = mywxWindow->GetExtraStyle();
// Looking at method wxWindow::GetFont
wxFont retwxWindowGetFont0 = mywxWindow->GetFont();
// Looking at method wxWindow::GetForegroundColour
// Looking at method wxWindow::GetGrandParent
wxWindow* retwxWindowGetGrandParent0 = mywxWindow->GetGrandParent();
// Looking at method wxWindow::GetHandle
mywxWindow->GetHandle();
// Looking at method wxWindow::GetHelpText
// Looking at method wxWindow::GetId
int retwxWindowGetId0 = mywxWindow->GetId();
// Looking at method wxWindow::GetLabel
// Looking at method wxWindow::GetMaxSize
wxSize retwxWindowGetMaxSize0 = mywxWindow->GetMaxSize();
// Looking at method wxWindow::GetMinSize
wxSize retwxWindowGetMinSize0 = mywxWindow->GetMinSize();
// Looking at method wxWindow::GetName
// Looking at method wxWindow::GetParent
// Looking at method wxWindow::GetPosition
wxPoint retwxWindowGetPosition0 = mywxWindow->GetPosition();
// Looking at method wxWindow::GetRect
// Looking at method wxWindow::GetScrollPos
// Looking at method wxWindow::GetScrollRange
// Looking at method wxWindow::GetScrollThumb
// Looking at method wxWindow::GetSize
int*  * wxWindowGetSizewidth0;
int*  * wxWindowGetSizeheight1;
mywxWindow->GetSize( * wxWindowGetSizewidth0,  * wxWindowGetSizeheight1);
wxSize retwxWindowGetSize1 = mywxWindow->GetSize();
// Looking at method wxWindow::GetSizer
wxSizer * retwxWindowGetSizer0 = mywxWindow->GetSizer();
// Looking at method wxWindow::GetTextExtent
// Looking at method wxWindow::GetTitle
// Looking at method wxWindow::GetToolTip
wxToolTip* retwxWindowGetToolTip0 = mywxWindow->GetToolTip();
// Looking at method wxWindow::GetUpdateRegion
// Looking at method wxWindow::GetValidator
wxValidator* retwxWindowGetValidator0 = mywxWindow->GetValidator();
// Looking at method wxWindow::GetVirtualSize
int*  * wxWindowGetVirtualSizewidth0;
int*  * wxWindowGetVirtualSizeheight1;
mywxWindow->GetVirtualSize( * wxWindowGetVirtualSizewidth0,  * wxWindowGetVirtualSizeheight1);
wxSize retwxWindowGetVirtualSize1 = mywxWindow->GetVirtualSize();
// Looking at method wxWindow::GetWindowStyleFlag
long retwxWindowGetWindowStyleFlag0 = mywxWindow->GetWindowStyleFlag();
// Looking at method wxWindow::GetWindowVariant
wxWindowVariant retwxWindowGetWindowVariant0 = mywxWindow->GetWindowVariant();
// Looking at method wxWindow::HasCapture
// Looking at method wxWindow::HasScrollbar
// Looking at method wxWindow::HasTransparentBackground
// Looking at method wxWindow::Hide
bool retwxWindowHide0 = mywxWindow->Hide();
// Looking at method wxWindow::InheritAttributes
mywxWindow->InheritAttributes();
// Looking at method wxWindow::InitDialog
mywxWindow->InitDialog();
// Looking at method wxWindow::InvalidateBestSize
mywxWindow->InvalidateBestSize();
// Looking at method wxWindow::IsEnabled
// Looking at method wxWindow::IsExposed
int  * wxWindowIsExposedx0;
int  * wxWindowIsExposedy1;
bool retwxWindowIsExposed0 = mywxWindow->IsExposed( * wxWindowIsExposedx0,  * wxWindowIsExposedy1);
wxPoint  * wxWindowIsExposedpt2;
bool retwxWindowIsExposed1 = mywxWindow->IsExposed( * wxWindowIsExposedpt2);
int  * wxWindowIsExposedx3;
int  * wxWindowIsExposedy4;
int  * wxWindowIsExposedw5;
int  * wxWindowIsExposedh6;
bool retwxWindowIsExposed2 = mywxWindow->IsExposed( * wxWindowIsExposedx3,  * wxWindowIsExposedy4,  * wxWindowIsExposedw5,  * wxWindowIsExposedh6);
wxRect  * wxWindowIsExposedrect7;
bool retwxWindowIsExposed3 = mywxWindow->IsExposed( * wxWindowIsExposedrect7);
// Looking at method wxWindow::IsRetained
// Looking at method wxWindow::IsShown
// Looking at method wxWindow::IsTopLevel
bool retwxWindowIsTopLevel0 = mywxWindow->IsTopLevel();
// Looking at method wxWindow::Layout
mywxWindow->Layout();
// Looking at method wxWindow::LineDown
// Looking at method wxWindow::LineUp
// Looking at method wxWindow::Lower
mywxWindow->Lower();
// Looking at method wxWindow::MakeModal
// Looking at method wxWindow::Move
int  * wxWindowMovex0;
int  * wxWindowMovey1;
mywxWindow->Move( * wxWindowMovex0,  * wxWindowMovey1);
wxPoint  * wxWindowMovept2;
mywxWindow->Move( * wxWindowMovept2);
// Looking at method wxWindow::MoveAfterInTabOrder
wxWindow * * wxWindowMoveAfterInTabOrderwin0;
mywxWindow->MoveAfterInTabOrder( * wxWindowMoveAfterInTabOrderwin0);
// Looking at method wxWindow::MoveBeforeInTabOrder
wxWindow * * wxWindowMoveBeforeInTabOrderwin0;
mywxWindow->MoveBeforeInTabOrder( * wxWindowMoveBeforeInTabOrderwin0);
// Looking at method wxWindow::Navigate
int  * wxWindowNavigateflags0;
bool retwxWindowNavigate0 = mywxWindow->Navigate( * wxWindowNavigateflags0);
// Looking at method wxWindow::OnInternalIdle
// Looking at method wxWindow::PageDown
// Looking at method wxWindow::PageUp
// Looking at method wxWindow::PopEventHandler
bool  * wxWindowPopEventHandlerdeleteHandler0;
wxEvtHandler* retwxWindowPopEventHandler0 = mywxWindow->PopEventHandler( * wxWindowPopEventHandlerdeleteHandler0);
// Looking at method wxWindow::PopupMenu
wxMenu*  * wxWindowPopupMenumenu0;
wxPoint  * wxWindowPopupMenupos1;
bool retwxWindowPopupMenu0 = mywxWindow->PopupMenu( * wxWindowPopupMenumenu0,  * wxWindowPopupMenupos1);
wxMenu*  * wxWindowPopupMenumenu2;
int  * wxWindowPopupMenux3;
int  * wxWindowPopupMenuy4;
bool retwxWindowPopupMenu1 = mywxWindow->PopupMenu( * wxWindowPopupMenumenu2,  * wxWindowPopupMenux3,  * wxWindowPopupMenuy4);
// Looking at method wxWindow::PushEventHandler
wxEvtHandler*  * wxWindowPushEventHandlerhandler0;
mywxWindow->PushEventHandler( * wxWindowPushEventHandlerhandler0);
// Looking at method wxWindow::Raise
mywxWindow->Raise();
// Looking at method wxWindow::Refresh
// Looking at method wxWindow::RefreshRect
wxRect  * wxWindowRefreshRectrect0;
bool  * wxWindowRefreshRecteraseBackground1;
mywxWindow->RefreshRect( * wxWindowRefreshRectrect0,  * wxWindowRefreshRecteraseBackground1);
// Looking at method wxWindow::ReleaseMouse
// Looking at method wxWindow::RemoveChild
// Looking at method wxWindow::RemoveEventHandler
wxEvtHandler * * wxWindowRemoveEventHandlerhandler0;
bool retwxWindowRemoveEventHandler0 = mywxWindow->RemoveEventHandler( * wxWindowRemoveEventHandlerhandler0);
// Looking at method wxWindow::Reparent
// Looking at method wxWindow::ScreenToClient
// Looking at method wxWindow::ScrollLines
// Looking at method wxWindow::ScrollPages
// Looking at method wxWindow::ScrollWindow
// Looking at method wxWindow::SetAcceleratorTable
// Looking at method wxWindow::SetAccessible
#if wxUSE_ACCESSIBILITY == 1
wxAccessible*  * wxWindowSetAccessibleaccessible0;
mywxWindow->SetAccessible( * wxWindowSetAccessibleaccessible0);
#endif //wxUSE_ACCESSIBILITY
// Looking at method wxWindow::SetAutoLayout
bool  * wxWindowSetAutoLayoutautoLayout0;
mywxWindow->SetAutoLayout( * wxWindowSetAutoLayoutautoLayout0);
// Looking at method wxWindow::SetBackgroundColour
// Looking at method wxWindow::SetBackgroundStyle
// Looking at method wxWindow::SetBestFittingSize
wxSize  * wxWindowSetBestFittingSizesize0;
mywxWindow->SetBestFittingSize( * wxWindowSetBestFittingSizesize0);
// Looking at method wxWindow::SetCaret
wxCaret * * wxWindowSetCaretcaret0;
mywxWindow->SetCaret( * wxWindowSetCaretcaret0);
// Looking at method wxWindow::SetClientSize
// Looking at method wxWindow::SetContainingSizer
wxSizer*  * wxWindowSetContainingSizersizer0;
mywxWindow->SetContainingSizer( * wxWindowSetContainingSizersizer0);
// Looking at method wxWindow::SetCursor
// Looking at method wxWindow::SetConstraints
wxLayoutConstraints*  * wxWindowSetConstraintsconstraints0;
mywxWindow->SetConstraints( * wxWindowSetConstraintsconstraints0);
// Looking at method wxWindow::SetInitialBestSize
// Looking at method wxWindow::SetMaxSize
wxSize  * wxWindowSetMaxSizesize0;
mywxWindow->SetMaxSize( * wxWindowSetMaxSizesize0);
// Looking at method wxWindow::SetMinSize
wxSize  * wxWindowSetMinSizesize0;
mywxWindow->SetMinSize( * wxWindowSetMinSizesize0);
// Looking at method wxWindow::SetOwnBackgroundColour
wxColour  * wxWindowSetOwnBackgroundColourcolour0;
mywxWindow->SetOwnBackgroundColour( * wxWindowSetOwnBackgroundColourcolour0);
// Looking at method wxWindow::SetOwnFont
wxFont  * wxWindowSetOwnFontfont0;
mywxWindow->SetOwnFont( * wxWindowSetOwnFontfont0);
// Looking at method wxWindow::SetOwnForegroundColour
wxColour  * wxWindowSetOwnForegroundColourcolour0;
mywxWindow->SetOwnForegroundColour( * wxWindowSetOwnForegroundColourcolour0);
// Looking at method wxWindow::SetDropTarget
wxDropTarget*  * wxWindowSetDropTargettarget0;
mywxWindow->SetDropTarget( * wxWindowSetDropTargettarget0);
// Looking at method wxWindow::SetEventHandler
wxEvtHandler*  * wxWindowSetEventHandlerhandler0;
mywxWindow->SetEventHandler( * wxWindowSetEventHandlerhandler0);
// Looking at method wxWindow::SetExtraStyle
long  * wxWindowSetExtraStyleexStyle0;
mywxWindow->SetExtraStyle( * wxWindowSetExtraStyleexStyle0);
// Looking at method wxWindow::SetFocus
// Looking at method wxWindow::SetFocusFromKbd
// Looking at method wxWindow::SetFont
wxFont  * wxWindowSetFontfont0;
mywxWindow->SetFont( * wxWindowSetFontfont0);
// Looking at method wxWindow::SetForegroundColour
// Looking at method wxWindow::SetHelpText
// Looking at method wxWindow::SetId
int  * wxWindowSetIdid0;
mywxWindow->SetId( * wxWindowSetIdid0);
// Looking at method wxWindow::SetLabel
// Looking at method wxWindow::SetName
// Looking at method wxWindow::SetPalette
// Looking at method wxWindow::SetScrollbar
// Looking at method wxWindow::SetScrollPage
// Looking at method wxWindow::SetScrollPos
// Looking at method wxWindow::SetScrollRange
// Looking at method wxWindow::SetSize
// Looking at method wxWindow::SetSizeHints
wxSize  * wxWindowSetSizeHintsminSize0;
wxSize  * wxWindowSetSizeHintsmaxSize1;
wxSize  * wxWindowSetSizeHintsincSize2;
mywxWindow->SetSizeHints( * wxWindowSetSizeHintsminSize0,  * wxWindowSetSizeHintsmaxSize1,  * wxWindowSetSizeHintsincSize2);
// Looking at method wxWindow::SetSizer
wxSizer*  * wxWindowSetSizersizer0;
bool  * wxWindowSetSizerdeleteOld1;
mywxWindow->SetSizer( * wxWindowSetSizersizer0,  * wxWindowSetSizerdeleteOld1);
// Looking at method wxWindow::SetSizerAndFit
wxSizer*  * wxWindowSetSizerAndFitsizer0;
bool  * wxWindowSetSizerAndFitdeleteOld1;
mywxWindow->SetSizerAndFit( * wxWindowSetSizerAndFitsizer0,  * wxWindowSetSizerAndFitdeleteOld1);
// Looking at method wxWindow::SetTitle
// Looking at method wxWindow::SetThemeEnabled
// Looking at method wxWindow::SetToolTip
wxString  * wxWindowSetToolTiptip0;
mywxWindow->SetToolTip( * wxWindowSetToolTiptip0);
wxToolTip*  * wxWindowSetToolTiptip1;
mywxWindow->SetToolTip( * wxWindowSetToolTiptip1);
// Looking at method wxWindow::SetValidator
// Looking at method wxWindow::SetVirtualSize
int  * wxWindowSetVirtualSizewidth0;
int  * wxWindowSetVirtualSizeheight1;
mywxWindow->SetVirtualSize( * wxWindowSetVirtualSizewidth0,  * wxWindowSetVirtualSizeheight1);
wxSize  * wxWindowSetVirtualSizesize2;
mywxWindow->SetVirtualSize( * wxWindowSetVirtualSizesize2);
// Looking at method wxWindow::SetVirtualSizeHints
wxSize  * wxWindowSetVirtualSizeHintsminSize0;
wxSize  * wxWindowSetVirtualSizeHintsmaxSize1;
mywxWindow->SetVirtualSizeHints( * wxWindowSetVirtualSizeHintsminSize0,  * wxWindowSetVirtualSizeHintsmaxSize1);
// Looking at method wxWindow::SetWindowStyle
long  * wxWindowSetWindowStylestyle0;
mywxWindow->SetWindowStyle( * wxWindowSetWindowStylestyle0);
// Looking at method wxWindow::SetWindowStyleFlag
// Looking at method wxWindow::SetWindowVariant
wxWindowVariant * wxWindowSetWindowVariantvariant0;
mywxWindow->SetWindowVariant( * wxWindowSetWindowVariantvariant0);
// Looking at method wxWindow::ShouldInheritColours
// Looking at method wxWindow::Show
// Looking at method wxWindow::Thaw
// Looking at method wxWindow::TransferDataFromWindow
// Looking at method wxWindow::TransferDataToWindow
// Looking at method wxWindow::Update
// Looking at method wxWindow::UpdateWindowUI
// Looking at method wxWindow::Validate
// Looking at method wxWindow::WarpPointer
int  * wxWindowWarpPointerx0;
int  * wxWindowWarpPointery1;
mywxWindow->WarpPointer( * wxWindowWarpPointerx0,  * wxWindowWarpPointery1);

// Looking at class wxWindowDC
wxWindowDC * mywxWindowDC;
// Looking at method wxWindowDC::wxWindowDC
wxWindow*  * wxWindowDCwxWindowDCwindow0;
wxWindowDC * newwxWindowDC0 = new wxWindowDC( * wxWindowDCwxWindowDCwindow0);

// Looking at class wxWindowDisabler
wxWindowDisabler * mywxWindowDisabler;
// Looking at method wxWindowDisabler::wxWindowDisabler
wxWindow * * wxWindowDisablerwxWindowDisablerwinToSkip0;
wxWindowDisabler * newwxWindowDisabler0 = new wxWindowDisabler( * wxWindowDisablerwxWindowDisablerwinToSkip0);

// Looking at class wxWizard
wxWizard * mywxWizard;
// Looking at method wxWizard::wxWizard
wxWizard * newwxWizard0 = new wxWizard();
wxWindow*  * wxWizardwxWizardparent0;
int  * wxWizardwxWizardid1;
wxString  * wxWizardwxWizardtitle2;
wxBitmap  * wxWizardwxWizardbitmap3;
wxPoint  * wxWizardwxWizardpos4;
long  * wxWizardwxWizardstyle5;
wxWizard * newwxWizard1 = new wxWizard( * wxWizardwxWizardparent0,  * wxWizardwxWizardid1,  * wxWizardwxWizardtitle2,  * wxWizardwxWizardbitmap3,  * wxWizardwxWizardpos4,  * wxWizardwxWizardstyle5);
// Looking at method wxWizard::Create
wxWindow*  * wxWizardCreateparent0;
int  * wxWizardCreateid1;
wxString  * wxWizardCreatetitle2;
wxBitmap  * wxWizardCreatebitmap3;
wxPoint  * wxWizardCreatepos4;
long  * wxWizardCreatestyle5;
bool retwxWizardCreate0 = mywxWizard->Create( * wxWizardCreateparent0,  * wxWizardCreateid1,  * wxWizardCreatetitle2,  * wxWizardCreatebitmap3,  * wxWizardCreatepos4,  * wxWizardCreatestyle5);
// Looking at method wxWizard::FitToPage
wxWizardPage*  * wxWizardFitToPagefirstPage0;
mywxWizard->FitToPage( * wxWizardFitToPagefirstPage0);
// Looking at method wxWizard::GetCurrentPage
wxWizardPage* retwxWizardGetCurrentPage0 = mywxWizard->GetCurrentPage();
// Looking at method wxWizard::GetPageAreaSizer
// Looking at method wxWizard::GetPageSize
wxSize retwxWizardGetPageSize0 = mywxWizard->GetPageSize();
// Looking at method wxWizard::HasNextPage
// Looking at method wxWizard::HasPrevPage
// Looking at method wxWizard::RunWizard
wxWizardPage*  * wxWizardRunWizardfirstPage0;
bool retwxWizardRunWizard0 = mywxWizard->RunWizard( * wxWizardRunWizardfirstPage0);
// Looking at method wxWizard::SetPageSize
wxSize  * wxWizardSetPageSizesizePage0;
mywxWizard->SetPageSize( * wxWizardSetPageSizesizePage0);
// Looking at method wxWizard::SetBorder
int  * wxWizardSetBorderborder0;
mywxWizard->SetBorder( * wxWizardSetBorderborder0);

// Looking at class wxWizardEvent
wxWizardEvent * mywxWizardEvent;
// Looking at method wxWizardEvent::wxWizardEvent
wxEventType  * wxWizardEventwxWizardEventtype0;
int  * wxWizardEventwxWizardEventid1;
bool  * wxWizardEventwxWizardEventdirection2;
wxWizardEvent * newwxWizardEvent0 = new wxWizardEvent( * wxWizardEventwxWizardEventtype0,  * wxWizardEventwxWizardEventid1,  * wxWizardEventwxWizardEventdirection2);
// Looking at method wxWizardEvent::GetDirection
bool retwxWizardEventGetDirection0 = mywxWizardEvent->GetDirection();
// Looking at method wxWizardEvent::GetPage
wxWizardPage* retwxWizardEventGetPage0 = mywxWizardEvent->GetPage();

// Looking at class wxWizardPageSimple
wxWizardPageSimple * mywxWizardPageSimple;
// Looking at method wxWizardPageSimple::wxWizardPageSimple
wxWizard*  * wxWizardPageSimplewxWizardPageSimpleparent0;
wxWizardPage*  * wxWizardPageSimplewxWizardPageSimpleprev1;
wxWizardPage*  * wxWizardPageSimplewxWizardPageSimplenext2;
wxBitmap  * wxWizardPageSimplewxWizardPageSimplebitmap3;
wxWizardPageSimple * newwxWizardPageSimple0 = new wxWizardPageSimple( * wxWizardPageSimplewxWizardPageSimpleparent0,  * wxWizardPageSimplewxWizardPageSimpleprev1,  * wxWizardPageSimplewxWizardPageSimplenext2,  * wxWizardPageSimplewxWizardPageSimplebitmap3);
// Looking at method wxWizardPageSimple::SetPrev
wxWizardPage*  * wxWizardPageSimpleSetPrevprev0;
mywxWizardPageSimple->SetPrev( * wxWizardPageSimpleSetPrevprev0);
// Looking at method wxWizardPageSimple::SetNext
wxWizardPage*  * wxWizardPageSimpleSetNextnext0;
mywxWizardPageSimple->SetNext( * wxWizardPageSimpleSetNextnext0);
// Looking at method wxWizardPageSimple::Chain
wxWizardPageSimple*  * wxWizardPageSimpleChainfirst0;
wxWizardPageSimple*  * wxWizardPageSimpleChainsecond1;
mywxWizardPageSimple->Chain( * wxWizardPageSimpleChainfirst0,  * wxWizardPageSimpleChainsecond1);

// Looking at class wxXmlResource
wxXmlResource * mywxXmlResource;
// Looking at method wxXmlResource::wxXmlResource
wxString  * wxXmlResourcewxXmlResourcefilemask0;
int  * wxXmlResourcewxXmlResourceflags1;
wxXmlResource * newwxXmlResource0 = new wxXmlResource( * wxXmlResourcewxXmlResourcefilemask0,  * wxXmlResourcewxXmlResourceflags1);
int  * wxXmlResourcewxXmlResourceflags2;
wxXmlResource * newwxXmlResource1 = new wxXmlResource( * wxXmlResourcewxXmlResourceflags2);
// Looking at method wxXmlResource::AddHandler
wxXmlResourceHandler*  * wxXmlResourceAddHandlerhandler0;
mywxXmlResource->AddHandler( * wxXmlResourceAddHandlerhandler0);
// Looking at method wxXmlResource::AttachUnknownControl
wxString  * wxXmlResourceAttachUnknownControlname0;
wxWindow*  * wxXmlResourceAttachUnknownControlcontrol1;
wxWindow*  * wxXmlResourceAttachUnknownControlparent2;
bool retwxXmlResourceAttachUnknownControl0 = mywxXmlResource->AttachUnknownControl( * wxXmlResourceAttachUnknownControlname0,  * wxXmlResourceAttachUnknownControlcontrol1,  * wxXmlResourceAttachUnknownControlparent2);
// Looking at method wxXmlResource::ClearHandlers
mywxXmlResource->ClearHandlers();
// Looking at method wxXmlResource::CompareVersion
int  * wxXmlResourceCompareVersionmajor0;
int  * wxXmlResourceCompareVersionminor1;
int  * wxXmlResourceCompareVersionrelease2;
int  * wxXmlResourceCompareVersionrevision3;
int retwxXmlResourceCompareVersion0 = mywxXmlResource->CompareVersion( * wxXmlResourceCompareVersionmajor0,  * wxXmlResourceCompareVersionminor1,  * wxXmlResourceCompareVersionrelease2,  * wxXmlResourceCompareVersionrevision3);
// Looking at method wxXmlResource::Get
wxXmlResource* retwxXmlResourceGet0 = mywxXmlResource->Get();
// Looking at method wxXmlResource::GetFlags
int retwxXmlResourceGetFlags0 = mywxXmlResource->GetFlags();
// Looking at method wxXmlResource::GetVersion
long retwxXmlResourceGetVersion0 = mywxXmlResource->GetVersion();
// Looking at method wxXmlResource::GetXRCID
wxChar*  * wxXmlResourceGetXRCIDstr_id0;
int retwxXmlResourceGetXRCID0 = mywxXmlResource->GetXRCID( * wxXmlResourceGetXRCIDstr_id0);
// Looking at method wxXmlResource::InitAllHandlers
mywxXmlResource->InitAllHandlers();
// Looking at method wxXmlResource::Load
wxString  * wxXmlResourceLoadfilemask0;
bool retwxXmlResourceLoad0 = mywxXmlResource->Load( * wxXmlResourceLoadfilemask0);
// Looking at method wxXmlResource::LoadBitmap
wxString  * wxXmlResourceLoadBitmapname0;
wxBitmap retwxXmlResourceLoadBitmap0 = mywxXmlResource->LoadBitmap( * wxXmlResourceLoadBitmapname0);
// Looking at method wxXmlResource::LoadDialog
wxWindow*  * wxXmlResourceLoadDialogparent0;
wxString  * wxXmlResourceLoadDialogname1;
wxDialog* retwxXmlResourceLoadDialog0 = mywxXmlResource->LoadDialog( * wxXmlResourceLoadDialogparent0,  * wxXmlResourceLoadDialogname1);
wxDialog*  * wxXmlResourceLoadDialogdlg2;
wxWindow*  * wxXmlResourceLoadDialogparent3;
wxString  * wxXmlResourceLoadDialogname4;
bool retwxXmlResourceLoadDialog1 = mywxXmlResource->LoadDialog( * wxXmlResourceLoadDialogdlg2,  * wxXmlResourceLoadDialogparent3,  * wxXmlResourceLoadDialogname4);
// Looking at method wxXmlResource::LoadFrame
wxFrame*  * wxXmlResourceLoadFrameframe0;
wxWindow*  * wxXmlResourceLoadFrameparent1;
wxString  * wxXmlResourceLoadFramename2;
bool retwxXmlResourceLoadFrame0 = mywxXmlResource->LoadFrame( * wxXmlResourceLoadFrameframe0,  * wxXmlResourceLoadFrameparent1,  * wxXmlResourceLoadFramename2);
// Looking at method wxXmlResource::LoadIcon
wxString  * wxXmlResourceLoadIconname0;
wxIcon retwxXmlResourceLoadIcon0 = mywxXmlResource->LoadIcon( * wxXmlResourceLoadIconname0);
// Looking at method wxXmlResource::LoadMenu
wxString  * wxXmlResourceLoadMenuname0;
wxMenu* retwxXmlResourceLoadMenu0 = mywxXmlResource->LoadMenu( * wxXmlResourceLoadMenuname0);
// Looking at method wxXmlResource::LoadMenuBar
wxWindow*  * wxXmlResourceLoadMenuBarparent0;
wxString  * wxXmlResourceLoadMenuBarname1;
wxMenuBar* retwxXmlResourceLoadMenuBar0 = mywxXmlResource->LoadMenuBar( * wxXmlResourceLoadMenuBarparent0,  * wxXmlResourceLoadMenuBarname1);
wxString  * wxXmlResourceLoadMenuBarname2;
wxMenuBar* retwxXmlResourceLoadMenuBar1 = mywxXmlResource->LoadMenuBar( * wxXmlResourceLoadMenuBarname2);
// Looking at method wxXmlResource::LoadPanel
wxWindow*  * wxXmlResourceLoadPanelparent0;
wxString  * wxXmlResourceLoadPanelname1;
wxPanel* retwxXmlResourceLoadPanel0 = mywxXmlResource->LoadPanel( * wxXmlResourceLoadPanelparent0,  * wxXmlResourceLoadPanelname1);
wxPanel*  * wxXmlResourceLoadPanelpanel2;
wxWindow*  * wxXmlResourceLoadPanelparent3;
wxString  * wxXmlResourceLoadPanelname4;
bool retwxXmlResourceLoadPanel1 = mywxXmlResource->LoadPanel( * wxXmlResourceLoadPanelpanel2,  * wxXmlResourceLoadPanelparent3,  * wxXmlResourceLoadPanelname4);
// Looking at method wxXmlResource::LoadToolBar
wxWindow*  * wxXmlResourceLoadToolBarparent0;
wxString  * wxXmlResourceLoadToolBarname1;
wxToolBar* retwxXmlResourceLoadToolBar0 = mywxXmlResource->LoadToolBar( * wxXmlResourceLoadToolBarparent0,  * wxXmlResourceLoadToolBarname1);
// Looking at method wxXmlResource::Set
wxXmlResource*  * wxXmlResourceSetres0;
wxXmlResource* retwxXmlResourceSet0 = mywxXmlResource->Set( * wxXmlResourceSetres0);
// Looking at method wxXmlResource::SetFlags
int  * wxXmlResourceSetFlagsflags0;
mywxXmlResource->SetFlags( * wxXmlResourceSetFlagsflags0);

// Looking at class wxZipClassFactory
wxZipClassFactory * mywxZipClassFactory;

// Looking at class wxZipEntry
wxZipEntry * mywxZipEntry;
// Looking at method wxZipEntry::wxZipEntry
wxString  * wxZipEntrywxZipEntryname0;
wxDateTime  * wxZipEntrywxZipEntrydt1;
off_t  * wxZipEntrywxZipEntrysize2;
wxZipEntry * newwxZipEntry0 = new wxZipEntry( * wxZipEntrywxZipEntryname0,  * wxZipEntrywxZipEntrydt1,  * wxZipEntrywxZipEntrysize2);
wxZipEntry  * wxZipEntrywxZipEntryentry3;
wxZipEntry * newwxZipEntry1 = new wxZipEntry( * wxZipEntrywxZipEntryentry3);
// Looking at method wxZipEntry::Clone
wxZipEntry* retwxZipEntryClone0 = mywxZipEntry->Clone();
// Looking at method wxZipEntry::Get/SetComment
wxString retwxZipEntryGetComment0 = mywxZipEntry->GetComment();
wxString  * wxZipEntrySetCommentcomment0;
mywxZipEntry->SetComment( * wxZipEntrySetCommentcomment0);
// Looking at method wxZipEntry::GetCompressedSize
off_t retwxZipEntryGetCompressedSize0 = mywxZipEntry->GetCompressedSize();
// Looking at method wxZipEntry::GetCrc
wxUint32 retwxZipEntryGetCrc0 = mywxZipEntry->GetCrc();
// Looking at method wxZipEntry::Get/SetExternalAttributes
wxUint32 retwxZipEntryGetExternalAttributes0 = mywxZipEntry->GetExternalAttributes();
wxUint32  * wxZipEntrySetExternalAttributesattr0;
mywxZipEntry->SetExternalAttributes( * wxZipEntrySetExternalAttributesattr0);
// Looking at method wxZipEntry::Get/SetExtra
const char* retwxZipEntryGetExtra0 = mywxZipEntry->GetExtra();
size_t retwxZipEntryGetExtraLen1 = mywxZipEntry->GetExtraLen();
char*  * wxZipEntrySetExtraextra0;
size_t  * wxZipEntrySetExtralen1;
mywxZipEntry->SetExtra( * wxZipEntrySetExtraextra0,  * wxZipEntrySetExtralen1);
// Looking at method wxZipEntry::GetFlags
int retwxZipEntryGetFlags0 = mywxZipEntry->GetFlags();
// Looking at method wxZipEntry::GetInternalName
wxString retwxZipEntryGetInternalName0 = mywxZipEntry->GetInternalName();
wxString  * wxZipEntryGetInternalNamename0;
wxPathFormat  * wxZipEntryGetInternalNameformat1;
bool*  * wxZipEntryGetInternalNamepIsDir2;
wxString retwxZipEntryGetInternalName1 = mywxZipEntry->GetInternalName( * wxZipEntryGetInternalNamename0,  * wxZipEntryGetInternalNameformat1,  * wxZipEntryGetInternalNamepIsDir2);
// Looking at method wxZipEntry::Get/SetLocalExtra
const char* retwxZipEntryGetLocalExtra0 = mywxZipEntry->GetLocalExtra();
size_t retwxZipEntryGetLocalExtraLen1 = mywxZipEntry->GetLocalExtraLen();
char*  * wxZipEntrySetLocalExtraextra0;
size_t  * wxZipEntrySetLocalExtralen1;
mywxZipEntry->SetLocalExtra( * wxZipEntrySetLocalExtraextra0,  * wxZipEntrySetLocalExtralen1);
// Looking at method wxZipEntry::Get/SetMethod
int retwxZipEntryGetMethod0 = mywxZipEntry->GetMethod();
int  * wxZipEntrySetMethodmethod0;
mywxZipEntry->SetMethod( * wxZipEntrySetMethodmethod0);
// Looking at method wxZipEntry::Get/SetMode
int retwxZipEntryGetMode0 = mywxZipEntry->GetMode();
int  * wxZipEntrySetModemode0;
mywxZipEntry->SetMode( * wxZipEntrySetModemode0);
// Looking at method wxZipEntry::SetNotifier
wxZipNotifier  * wxZipEntrySetNotifiernotifier0;
mywxZipEntry->SetNotifier( * wxZipEntrySetNotifiernotifier0);
mywxZipEntry->UnsetNotifier();
// Looking at method wxZipEntry::Get/SetSystemMadeBy
int retwxZipEntryGetSystemMadeBy0 = mywxZipEntry->GetSystemMadeBy();
int  * wxZipEntrySetSystemMadeBysystem0;
mywxZipEntry->SetSystemMadeBy( * wxZipEntrySetSystemMadeBysystem0);
// Looking at method wxZipEntry::IsMadeByUnix
bool retwxZipEntryIsMadeByUnix0 = mywxZipEntry->IsMadeByUnix();
// Looking at method wxZipEntry::IsText/SetIsText
bool retwxZipEntryIsText0 = mywxZipEntry->IsText();
bool  * wxZipEntrySetIsTextisText0;
mywxZipEntry->SetIsText( * wxZipEntrySetIsTextisText0);

// Looking at class wxZipInputStream
wxZipInputStream * mywxZipInputStream;
// Looking at method wxZipInputStream::wxZipInputStream
wxInputStream  * wxZipInputStreamwxZipInputStreamstream0;
wxMBConv  * wxZipInputStreamwxZipInputStreamconv1;
wxZipInputStream * newwxZipInputStream0 = new wxZipInputStream( * wxZipInputStreamwxZipInputStreamstream0,  * wxZipInputStreamwxZipInputStreamconv1);
wxString  * wxZipInputStreamwxZipInputStreamarchive2;
wxString  * wxZipInputStreamwxZipInputStreamfile3;
wxZipInputStream * newwxZipInputStream1 = new wxZipInputStream( * wxZipInputStreamwxZipInputStreamarchive2,  * wxZipInputStreamwxZipInputStreamfile3);
// Looking at method wxZipInputStream::CloseEntry
bool retwxZipInputStreamCloseEntry0 = mywxZipInputStream->CloseEntry();
// Looking at method wxZipInputStream::GetComment
wxString retwxZipInputStreamGetComment0 = mywxZipInputStream->GetComment();
// Looking at method wxZipInputStream::GetNextEntry
wxZipEntry* retwxZipInputStreamGetNextEntry0 = mywxZipInputStream->GetNextEntry();
// Looking at method wxZipInputStream::GetTotalEntries
int retwxZipInputStreamGetTotalEntries0 = mywxZipInputStream->GetTotalEntries();
// Looking at method wxZipInputStream::OpenEntry
wxZipEntry  * wxZipInputStreamOpenEntryentry0;
bool retwxZipInputStreamOpenEntry0 = mywxZipInputStream->OpenEntry( * wxZipInputStreamOpenEntryentry0);

// Looking at class wxZipNotifier
wxZipNotifier * mywxZipNotifier;
// Looking at method wxZipNotifier::OnEntryUpdated
wxZipEntry  * wxZipNotifierOnEntryUpdatedentry0;
mywxZipNotifier->OnEntryUpdated( * wxZipNotifierOnEntryUpdatedentry0);

// Looking at class wxZipOutputStream
wxZipOutputStream * mywxZipOutputStream;
// Looking at method wxZipOutputStream::wxZipOutputStream
wxOutputStream  * wxZipOutputStreamwxZipOutputStreamstream0;
int  * wxZipOutputStreamwxZipOutputStreamlevel1;
wxMBConv  * wxZipOutputStreamwxZipOutputStreamconv2;
wxZipOutputStream * newwxZipOutputStream0 = new wxZipOutputStream( * wxZipOutputStreamwxZipOutputStreamstream0,  * wxZipOutputStreamwxZipOutputStreamlevel1,  * wxZipOutputStreamwxZipOutputStreamconv2);
// Looking at method wxZipOutputStream::Close
bool retwxZipOutputStreamClose0 = mywxZipOutputStream->Close();
// Looking at method wxZipOutputStream::CloseEntry
bool retwxZipOutputStreamCloseEntry0 = mywxZipOutputStream->CloseEntry();
// Looking at method wxZipOutputStream::CopyArchiveMetaData
wxZipInputStream  * wxZipOutputStreamCopyArchiveMetaDatainputStream0;
bool retwxZipOutputStreamCopyArchiveMetaData0 = mywxZipOutputStream->CopyArchiveMetaData( * wxZipOutputStreamCopyArchiveMetaDatainputStream0);
// Looking at method wxZipOutputStream::CopyEntry
wxZipEntry*  * wxZipOutputStreamCopyEntryentry0;
wxZipInputStream  * wxZipOutputStreamCopyEntryinputStream1;
bool retwxZipOutputStreamCopyEntry0 = mywxZipOutputStream->CopyEntry( * wxZipOutputStreamCopyEntryentry0,  * wxZipOutputStreamCopyEntryinputStream1);
// Looking at method wxZipOutputStream::Get/SetLevel
int retwxZipOutputStreamGetLevel0 = mywxZipOutputStream->GetLevel();
int  * wxZipOutputStreamSetLevellevel0;
mywxZipOutputStream->SetLevel( * wxZipOutputStreamSetLevellevel0);
// Looking at method wxZipOutputStream::PutNextDirEntry
wxString  * wxZipOutputStreamPutNextDirEntryname0;
wxDateTime  * wxZipOutputStreamPutNextDirEntrydt1;
bool retwxZipOutputStreamPutNextDirEntry0 = mywxZipOutputStream->PutNextDirEntry( * wxZipOutputStreamPutNextDirEntryname0,  * wxZipOutputStreamPutNextDirEntrydt1);
// Looking at method wxZipOutputStream::PutNextEntry
wxZipEntry*  * wxZipOutputStreamPutNextEntryentry0;
bool retwxZipOutputStreamPutNextEntry0 = mywxZipOutputStream->PutNextEntry( * wxZipOutputStreamPutNextEntryentry0);
wxString  * wxZipOutputStreamPutNextEntryname1;
wxDateTime  * wxZipOutputStreamPutNextEntrydt2;
off_t  * wxZipOutputStreamPutNextEntrysize3;
bool retwxZipOutputStreamPutNextEntry1 = mywxZipOutputStream->PutNextEntry( * wxZipOutputStreamPutNextEntryname1,  * wxZipOutputStreamPutNextEntrydt2,  * wxZipOutputStreamPutNextEntrysize3);
// Looking at method wxZipOutputStream::SetComment
wxString  * wxZipOutputStreamSetCommentcomment0;
mywxZipOutputStream->SetComment( * wxZipOutputStreamSetCommentcomment0);

// Looking at class wxZlibInputStream
wxZlibInputStream * mywxZlibInputStream;
// Looking at method wxZlibInputStream::wxZlibInputStream
wxInputStream  * wxZlibInputStreamwxZlibInputStreamstream0;
int  * wxZlibInputStreamwxZlibInputStreamflags1;
wxZlibInputStream * newwxZlibInputStream0 = new wxZlibInputStream( * wxZlibInputStreamwxZlibInputStreamstream0,  * wxZlibInputStreamwxZlibInputStreamflags1);
// Looking at method wxZlibInputStream::CanHandleGZip
static bool retwxZlibInputStreamCanHandleGZip0 = mywxZlibInputStream->CanHandleGZip();

// Looking at class wxZlibOutputStream
wxZlibOutputStream * mywxZlibOutputStream;
// Looking at method wxZlibOutputStream::wxZlibOutputStream
wxOutputStream  * wxZlibOutputStreamwxZlibOutputStreamstream0;
int  * wxZlibOutputStreamwxZlibOutputStreamlevel1;
int  * wxZlibOutputStreamwxZlibOutputStreamflags2;
wxZlibOutputStream * newwxZlibOutputStream0 = new wxZlibOutputStream( * wxZlibOutputStreamwxZlibOutputStreamstream0,  * wxZlibOutputStreamwxZlibOutputStreamlevel1,  * wxZlibOutputStreamwxZlibOutputStreamflags2);
// Looking at method wxZlibOutputStream::CanHandleGZip
static bool retwxZlibOutputStreamCanHandleGZip0 = mywxZlibOutputStream->CanHandleGZip();
}