/********************************************************
* cint/cint/lib/dll_stl/G__cpp_vectorbool.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/
#include "cint/cint/lib/dll_stl/G__cpp_vectorbool.h" //newlink 3678 

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtable();

extern "C" void G__set_cpp_environment() {
  G__add_compiledheader("cint/cint/lib/dll_stl/vecbool.h");
  G__cpp_reset_tagtable();
}
#include <new>
extern "C" int G__cpp_dllrev() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* allocator<bool> */
static int G__vectorbool_8_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   allocator<bool>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new allocator<bool>[n];
     } else {
       p = new((void*) gvp) allocator<bool>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new allocator<bool>;
     } else {
       p = new((void*) gvp) allocator<bool>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   allocator<bool>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new allocator<bool>(*(allocator<bool>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) allocator<bool>(*(allocator<bool>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 71, (long) ((const allocator<bool>*) G__getstructoffset())->address(*(bool*) G__Boolref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 71, (long) ((const allocator<bool>*) G__getstructoffset())->address(*(bool*) G__Boolref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 71, (long) ((allocator<bool>*) G__getstructoffset())->allocate((allocator<bool>::size_type) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 71, (long) ((allocator<bool>*) G__getstructoffset())->allocate((allocator<bool>::size_type) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((allocator<bool>*) G__getstructoffset())->deallocate((allocator<bool>::pointer) G__int(libp->para[0]), (allocator<bool>::size_type) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const allocator<bool>*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((allocator<bool>*) G__getstructoffset())->construct((allocator<bool>::pointer) G__int(libp->para[0]), *(bool*) G__Boolref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_8_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((allocator<bool>*) G__getstructoffset())->destroy((allocator<bool>::pointer) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef allocator<bool> G__TallocatorlEboolgR;
static int G__vectorbool_8_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (allocator<bool>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((allocator<bool>*) (soff+(sizeof(allocator<bool>)*i)))->~G__TallocatorlEboolgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (allocator<bool>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((allocator<bool>*) (soff))->~G__TallocatorlEboolgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__vectorbool_8_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   allocator<bool>* dest = (allocator<bool>*) G__getstructoffset();
   const allocator<bool>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<bool,allocator<bool> > */
static int G__vectorbool_9_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >(*(bool*) G__Boolref(&libp->para[0]));
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >(*(bool*) G__Boolref(&libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new vector<bool,allocator<bool> >[n];
       } else {
         p = new((void*) gvp) vector<bool,allocator<bool> >[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new vector<bool,allocator<bool> >;
       } else {
         p = new((void*) gvp) vector<bool,allocator<bool> >;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]), *(bool*) G__Boolref(&libp->para[1]));
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]), *(bool*) G__Boolref(&libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<bool,allocator<bool> >(*(vector<bool,allocator<bool> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<bool,allocator<bool> >(*(vector<bool,allocator<bool> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >& obj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->operator=(*(vector<bool,allocator<bool> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->assign((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]), (const bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->begin();
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::const_iterator* pobj;
         const vector<bool,allocator<bool> >::const_iterator xobj = ((const vector<bool,allocator<bool> >*) G__getstructoffset())->begin();
         pobj = new vector<bool,allocator<bool> >::const_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->end();
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::const_iterator* pobj;
         const vector<bool,allocator<bool> >::const_iterator xobj = ((const vector<bool,allocator<bool> >*) G__getstructoffset())->end();
         pobj = new vector<bool,allocator<bool> >::const_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reverse_iterator* pobj;
         vector<bool,allocator<bool> >::reverse_iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->rbegin();
         pobj = new vector<bool,allocator<bool> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::const_reverse_iterator* pobj;
         const vector<bool,allocator<bool> >::const_reverse_iterator xobj = ((const vector<bool,allocator<bool> >*) G__getstructoffset())->rbegin();
         pobj = new vector<bool,allocator<bool> >::const_reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reverse_iterator* pobj;
         vector<bool,allocator<bool> >::reverse_iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->rend();
         pobj = new vector<bool,allocator<bool> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::const_reverse_iterator* pobj;
         const vector<bool,allocator<bool> >::const_reverse_iterator xobj = ((const vector<bool,allocator<bool> >*) G__getstructoffset())->rend();
         pobj = new vector<bool,allocator<bool> >::const_reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->resize((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->resize((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->reserve((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reference* pobj;
         vector<bool,allocator<bool> >::reference xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->operator[]((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::reference(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->operator[]((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->at((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reference* pobj;
         vector<bool,allocator<bool> >::reference xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->at((vector<bool,allocator<bool> >::size_type) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::reference(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reference* pobj;
         vector<bool,allocator<bool> >::reference xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->front();
         pobj = new vector<bool,allocator<bool> >::reference(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->front());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reference* pobj;
         vector<bool,allocator<bool> >::reference xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->back();
         pobj = new vector<bool,allocator<bool> >::reference(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >*) G__getstructoffset())->back());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->push_back(*(bool*) G__Boolref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->insert(*((vector<bool,allocator<bool> >::iterator*) G__int(libp->para[0])), *(bool*) G__Boolref(&libp->para[1]));
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->insert(*((vector<bool,allocator<bool> >::iterator*) G__int(libp->para[0])), (vector<bool,allocator<bool> >::size_type) G__int(libp->para[1])
, *(bool*) G__Boolref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->erase(*((vector<bool,allocator<bool> >::iterator*) G__int(libp->para[0])));
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >*) G__getstructoffset())->erase(*((vector<bool,allocator<bool> >::iterator*) G__int(libp->para[0])), *((vector<bool,allocator<bool> >::iterator*) G__int(libp->para[1])));
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->swap(*(vector<bool,allocator<bool> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_9_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<bool,allocator<bool> > G__TvectorlEboolcOallocatorlEboolgRsPgR;
static int G__vectorbool_9_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<bool,allocator<bool> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<bool,allocator<bool> >*) (soff+(sizeof(vector<bool,allocator<bool> >)*i)))->~G__TvectorlEboolcOallocatorlEboolgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<bool,allocator<bool> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<bool,allocator<bool> >*) (soff))->~G__TvectorlEboolcOallocatorlEboolgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<bool,allocator<bool> >::iterator */
static int G__vectorbool_10_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >::iterator[n];
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >::iterator;
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::iterator& obj = ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator=(*(vector<bool,allocator<bool> >::iterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::iterator& obj = ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::iterator& obj = ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::iterator* pobj;
         vector<bool,allocator<bool> >::iterator xobj = ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_10_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((vector<bool,allocator<bool> >::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__vectorbool_10_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   vector<bool,allocator<bool> >::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new vector<bool,allocator<bool> >::iterator(*(vector<bool,allocator<bool> >::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<bool,allocator<bool> >::iterator G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator;
static int G__vectorbool_10_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<bool,allocator<bool> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<bool,allocator<bool> >::iterator*) (soff+(sizeof(vector<bool,allocator<bool> >::iterator)*i)))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<bool,allocator<bool> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<bool,allocator<bool> >::iterator*) (soff))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<bool,allocator<bool> >::reverse_iterator */
static int G__vectorbool_11_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >::reverse_iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >::reverse_iterator[n];
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >::reverse_iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<bool,allocator<bool> >::reverse_iterator;
     } else {
       p = new((void*) gvp) vector<bool,allocator<bool> >::reverse_iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<bool,allocator<bool> >::reverse_iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<bool,allocator<bool> >::reverse_iterator(*(vector<bool,allocator<bool> >::reverse_iterator*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<bool,allocator<bool> >::reverse_iterator(*(vector<bool,allocator<bool> >::reverse_iterator*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::reverse_iterator& obj = ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator=(*(vector<bool,allocator<bool> >::reverse_iterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::reverse_iterator& obj = ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reverse_iterator* pobj;
         vector<bool,allocator<bool> >::reverse_iterator xobj = ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::reverse_iterator& obj = ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool,allocator<bool> >::reverse_iterator* pobj;
         vector<bool,allocator<bool> >::reverse_iterator xobj = ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<bool,allocator<bool> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_11_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((vector<bool,allocator<bool> >::reverse_iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<bool,allocator<bool> >::reverse_iterator G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator;
static int G__vectorbool_11_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<bool,allocator<bool> >::reverse_iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<bool,allocator<bool> >::reverse_iterator*) (soff+(sizeof(vector<bool,allocator<bool> >::reverse_iterator)*i)))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<bool,allocator<bool> >::reverse_iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<bool,allocator<bool> >::reverse_iterator*) (soff))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<bool,allocator<bool> >::reference */
static int G__vectorbool_12_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<bool,allocator<bool> >::reference*) G__getstructoffset())->operator bool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_12_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::reference& obj = ((vector<bool,allocator<bool> >::reference*) G__getstructoffset())->operator=((const bool) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_12_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool,allocator<bool> >::reference& obj = ((vector<bool,allocator<bool> >::reference*) G__getstructoffset())->operator=(*(vector<bool,allocator<bool> >::reference*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__vectorbool_12_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<bool,allocator<bool> >::reference*) G__getstructoffset())->flip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<bool,allocator<bool> >::reference G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreference;
static int G__vectorbool_12_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<bool,allocator<bool> >::reference*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<bool,allocator<bool> >::reference*) (soff+(sizeof(vector<bool,allocator<bool> >::reference)*i)))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreference();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<bool,allocator<bool> >::reference*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<bool,allocator<bool> >::reference*) (soff))->~G__TvectorlEboolcOallocatorlEboolgRsPgRcLcLreference();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* allocator<bool> */

/* vector<bool,allocator<bool> > */

/* vector<bool,allocator<bool> >::iterator */

/* vector<bool,allocator<bool> >::reverse_iterator */

/* vector<bool,allocator<bool> >::reference */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfunc {
 public:
  G__Sizep2memfunc(): p(&G__Sizep2memfunc::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfunc::*p)();
};

size_t G__get_sizep2memfunc()
{
  G__Sizep2memfunc a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritance() {

   /* Setting up class inheritance */
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetable() {

   /* Setting up typedef entry */
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",71,-1,0,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",71,-1,256,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",103,-1,1,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",103,-1,257,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",103,-1,0,G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",103,-1,0,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",103,-1,0,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",103,-1,0,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* allocator<bool> */
static void G__setup_memvarallocatorlEboolgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   { allocator<bool> *p; p=(allocator<bool>*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<bool,allocator<bool> > */
static void G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   { vector<bool,allocator<bool> > *p; p=(vector<bool,allocator<bool> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<bool,allocator<bool> >::iterator */
static void G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator));
   { vector<bool,allocator<bool> >::iterator *p; p=(vector<bool,allocator<bool> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<bool,allocator<bool> >::reverse_iterator */
static void G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator));
   { vector<bool,allocator<bool> >::reverse_iterator *p; p=(vector<bool,allocator<bool> >::reverse_iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<bool,allocator<bool> >::reference */
static void G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLreference(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference));
   { vector<bool,allocator<bool> >::reference *p; p=(vector<bool,allocator<bool> >::reference*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvar() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncallocatorlEboolgR(void) {
   /* allocator<bool> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__LN_allocatorlEboolgR));
   G__memfunc_setup("allocator<bool>",1511,G__vectorbool_8_0_1, 105, G__get_linked_tagnum(&G__LN_allocatorlEboolgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("allocator<bool>",1511,G__vectorbool_8_0_2, 105, G__get_linked_tagnum(&G__LN_allocatorlEboolgR), -1, 0, 1, 1, 1, 0, "u 'allocator<bool>' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("address",742,G__vectorbool_8_0_3, 71, -1, G__defined_typename("allocator<bool>::pointer"), 0, 1, 1, 1, 8, "g - 'allocator<bool>::reference' 0 - __x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("address",742,G__vectorbool_8_0_4, 71, -1, G__defined_typename("allocator<bool>::const_pointer"), 0, 1, 1, 1, 8, "g - 'allocator<bool>::const_reference' 10 - __x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("allocate",837,G__vectorbool_8_0_5, 71, -1, -1, 0, 2, 1, 1, 0, 
"h - 'allocator<bool>::size_type' 0 - __n Y - - 10 '0' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("deallocate",1038,G__vectorbool_8_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'allocator<bool>::pointer' 0 - __p h - 'allocator<bool>::size_type' 0 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__vectorbool_8_0_7, 104, -1, G__defined_typename("allocator<bool>::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("construct",997,G__vectorbool_8_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'allocator<bool>::pointer' 0 - __p g - - 11 - __val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("destroy",778,G__vectorbool_8_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "G - 'allocator<bool>::pointer' 0 - __p", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~allocator<bool>", 1637, G__vectorbool_8_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__vectorbool_8_0_11, (int) ('u'), G__get_linked_tagnum(&G__LN_allocatorlEboolgR), -1, 1, 1, 1, 1, 0, "u 'allocator<bool>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgR(void) {
   /* vector<bool,allocator<bool> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__memfunc_setup("vector<bool,allocator<bool> >",2796,G__vectorbool_9_0_1, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR), -1, 0, 1, 5, 1, 0, "g - - 11 'bool()' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<bool,allocator<bool> >",2796,G__vectorbool_9_0_2, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR), -1, 0, 2, 5, 1, 0, 
"h - 'vector<bool,allocator<bool> >::size_type' 0 - n g - - 11 'bool()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<bool,allocator<bool> >",2796,G__vectorbool_9_0_3, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__vectorbool_9_0_4, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("assign",645,G__vectorbool_9_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<bool,allocator<bool> >::size_type' 0 - n g - - 10 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__vectorbool_9_0_6, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__vectorbool_9_0_7, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), G__defined_typename("vector<bool,allocator<bool> >::const_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__vectorbool_9_0_8, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__vectorbool_9_0_9, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), G__defined_typename("vector<bool,allocator<bool> >::const_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__vectorbool_9_0_10, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__vectorbool_9_0_11, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), G__defined_typename("vector<bool,allocator<bool> >::const_reverse_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__vectorbool_9_0_12, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__vectorbool_9_0_13, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), G__defined_typename("vector<bool,allocator<bool> >::const_reverse_iterator"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__vectorbool_9_0_14, 104, -1, G__defined_typename("vector<bool,allocator<bool> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__vectorbool_9_0_15, 104, -1, G__defined_typename("vector<bool,allocator<bool> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__vectorbool_9_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<bool,allocator<bool> >::size_type' 0 - sz g - - 0 'false' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__vectorbool_9_0_17, 104, -1, G__defined_typename("vector<bool,allocator<bool> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__vectorbool_9_0_18, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__vectorbool_9_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<bool,allocator<bool> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__vectorbool_9_0_20, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 1, 1, 1, 0, "h - 'vector<bool,allocator<bool> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__vectorbool_9_0_21, 103, -1, G__defined_typename("vector<bool,allocator<bool> >::const_reference"), 0, 1, 1, 1, 8, "h - 'vector<bool,allocator<bool> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__vectorbool_9_0_22, 103, -1, G__defined_typename("vector<bool,allocator<bool> >::const_reference"), 0, 1, 1, 1, 8, "h - 'vector<bool,allocator<bool> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__vectorbool_9_0_23, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 1, 1, 1, 0, "h - 'vector<bool,allocator<bool> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__vectorbool_9_0_24, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__vectorbool_9_0_25, 103, -1, G__defined_typename("vector<bool,allocator<bool> >::const_reference"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__vectorbool_9_0_26, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__vectorbool_9_0_27, 103, -1, G__defined_typename("vector<bool,allocator<bool> >::const_reference"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__vectorbool_9_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__vectorbool_9_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__vectorbool_9_0_30, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<bool,allocator<bool> >::iterator' - 0 - position g - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__vectorbool_9_0_31, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<bool,allocator<bool> >::iterator' - 0 - position h - 'vector<bool,allocator<bool> >::size_type' 0 - n "
"g - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__vectorbool_9_0_32, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__vectorbool_9_0_33, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<bool,allocator<bool> >::iterator' - 0 - first u 'vector<bool,allocator<bool> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__vectorbool_9_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__vectorbool_9_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<bool,allocator<bool> >", 2922, G__vectorbool_9_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator(void) {
   /* vector<bool,allocator<bool> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__vectorbool_10_0_1, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__vectorbool_10_0_2, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::iterator' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__vectorbool_10_0_3, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__vectorbool_10_0_4, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__vectorbool_10_0_5, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__vectorbool_10_0_6, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__vectorbool_10_0_7, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__vectorbool_10_0_8, (int) ('i'), G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__vectorbool_10_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator(void) {
   /* vector<bool,allocator<bool> >::reverse_iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator));
   G__memfunc_setup("reverse_iterator",1733,G__vectorbool_11_0_1, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reverse_iterator",1733,G__vectorbool_11_0_2, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::reverse_iterator' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__vectorbool_11_0_3, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 1, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::reverse_iterator' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__vectorbool_11_0_4, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__vectorbool_11_0_5, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__vectorbool_11_0_6, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__vectorbool_11_0_7, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__vectorbool_11_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~reverse_iterator", 1859, G__vectorbool_11_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLreference(void) {
   /* vector<bool,allocator<bool> >::reference */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference));
   G__memfunc_setup("reference",943,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reference",943,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 0, 1, 1, 4, 0, "u 'vector<bool,allocator<bool> >::reference' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator bool",1336,G__vectorbool_12_0_3, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__vectorbool_12_0_4, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 1, 1, 1, 1, 0, "g - - 10 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__vectorbool_12_0_5, 117, G__get_linked_tagnum(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference), -1, 1, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >::reference' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("flip",427,G__vectorbool_12_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~reference", 1069, G__vectorbool_12_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfunc() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();


   G__resetglobalenv();
}
extern "C" void G__cpp_setup_global() {
  G__cpp_setup_global0();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();


   G__resetifuncposition();
}

extern "C" void G__cpp_setup_func() {
  G__cpp_setup_func0();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__LN_allocatorlEboolgR = { "allocator<bool>" , 99 , -1 };
G__linked_taginfo G__LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator = { "vector<bool,allocator<bool> >::iterator" , 99 , -1 };
G__linked_taginfo G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator = { "vector<bool,allocator<bool> >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference = { "vector<bool,allocator<bool> >::reference" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtable() {
  G__LN_allocatorlEboolgR.tagnum = -1 ;
  G__LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator.tagnum = -1 ;
  G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtable() {

   /* Setting up class,struct,union tag entry */
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__LN_allocatorlEboolgR),sizeof(allocator<bool>),-1,1792,(char*)NULL,G__setup_memvarallocatorlEboolgR,G__setup_memfuncallocatorlEboolgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__LN_vectorlEboolcOallocatorlEboolgRsPgR),sizeof(vector<bool,allocator<bool> >),-1,3072,(char*)NULL,G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgR,G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLiterator),sizeof(vector<bool,allocator<bool> >::iterator),-1,3328,(char*)NULL,G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator,G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator),sizeof(vector<bool,allocator<bool> >::reverse_iterator),-1,3840,(char*)NULL,G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator,G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLreverse_iterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__LN_vectorlEboolcOallocatorlEboolgRsPgRcLcLreference),sizeof(vector<bool,allocator<bool> >::reference),-1,3840,(char*)NULL,G__setup_memvarvectorlEboolcOallocatorlEboolgRsPgRcLcLreference,G__setup_memfuncvectorlEboolcOallocatorlEboolgRsPgRcLcLreference);
}
extern "C" void G__cpp_setup(void) {
  G__check_setup_version(30051515,"G__cpp_setup()");
  G__set_cpp_environment();
  G__cpp_setup_tagtable();

  G__cpp_setup_inheritance();

  G__cpp_setup_typetable();

  G__cpp_setup_memvar();

  G__cpp_setup_memfunc();
  G__cpp_setup_global();
  G__cpp_setup_func();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfunc();
  return;
}
class G__cpp_setup_init {
  public:
    G__cpp_setup_init() { G__add_setup_func("G__Default",(G__incsetup)(&G__cpp_setup)); }
   ~G__cpp_setup_init() { G__remove_setup_func("G__Default"); }
};
G__cpp_setup_init G__cpp_setup_initializer;

