Changeset 16478


Ignore:
Timestamp:
Aug 3, 2016, 2:40:21 PM (3 years ago)
Author:
dcorreia
Message:

Updated middleware Python wrapper files

Location:
internals/2016/linuxloginsmartcardwizard/trunk/proto1
Files:
2 added
6 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • internals/2016/linuxloginsmartcardwizard/trunk/proto1/eidlibPython_Wrapper/GeneratedFiles/eidlibPython_Wrapper.cpp

    r16468 r16478  
    29362936
    29372937#define SWIGTYPE_p_char swig_types[0]
    2938 #define SWIGTYPE_p_eIDMW__PTEIDPin swig_types[1]
    2939 #define SWIGTYPE_p_eIDMW__PTEIDPins swig_types[2]
    2940 #define SWIGTYPE_p_eIDMW__PTEID_ADDR swig_types[3]
    2941 #define SWIGTYPE_p_eIDMW__PTEID_Address swig_types[4]
    2942 #define SWIGTYPE_p_eIDMW__PTEID_Biometric swig_types[5]
    2943 #define SWIGTYPE_p_eIDMW__PTEID_ByteArray swig_types[6]
    2944 #define SWIGTYPE_p_eIDMW__PTEID_CCXML_Doc swig_types[7]
    2945 #define SWIGTYPE_p_eIDMW__PTEID_Card swig_types[8]
    2946 #define SWIGTYPE_p_eIDMW__PTEID_CardVersionInfo swig_types[9]
    2947 #define SWIGTYPE_p_eIDMW__PTEID_Certif swig_types[10]
    2948 #define SWIGTYPE_p_eIDMW__PTEID_Certificate swig_types[11]
    2949 #define SWIGTYPE_p_eIDMW__PTEID_Certificates swig_types[12]
    2950 #define SWIGTYPE_p_eIDMW__PTEID_Certifs swig_types[13]
    2951 #define SWIGTYPE_p_eIDMW__PTEID_Config swig_types[14]
    2952 #define SWIGTYPE_p_eIDMW__PTEID_Crypto swig_types[15]
    2953 #define SWIGTYPE_p_eIDMW__PTEID_EIDCard swig_types[16]
    2954 #define SWIGTYPE_p_eIDMW__PTEID_EId swig_types[17]
    2955 #define SWIGTYPE_p_eIDMW__PTEID_ExBadTransaction swig_types[18]
    2956 #define SWIGTYPE_p_eIDMW__PTEID_ExBadUsage swig_types[19]
    2957 #define SWIGTYPE_p_eIDMW__PTEID_ExCardBadType swig_types[20]
    2958 #define SWIGTYPE_p_eIDMW__PTEID_ExCardChanged swig_types[21]
    2959 #define SWIGTYPE_p_eIDMW__PTEID_ExCardTypeUnknown swig_types[22]
    2960 #define SWIGTYPE_p_eIDMW__PTEID_ExCertNoIssuer swig_types[23]
    2961 #define SWIGTYPE_p_eIDMW__PTEID_ExCertNoRoot swig_types[24]
    2962 #define SWIGTYPE_p_eIDMW__PTEID_ExCmdNotAllowed swig_types[25]
    2963 #define SWIGTYPE_p_eIDMW__PTEID_ExCmdNotSupported swig_types[26]
    2964 #define SWIGTYPE_p_eIDMW__PTEID_ExDocTypeUnknown swig_types[27]
    2965 #define SWIGTYPE_p_eIDMW__PTEID_ExFileTypeUnknown swig_types[28]
    2966 #define SWIGTYPE_p_eIDMW__PTEID_ExNoCardPresent swig_types[29]
    2967 #define SWIGTYPE_p_eIDMW__PTEID_ExNoReader swig_types[30]
    2968 #define SWIGTYPE_p_eIDMW__PTEID_ExNotAllowByUser swig_types[31]
    2969 #define SWIGTYPE_p_eIDMW__PTEID_ExParamRange swig_types[32]
    2970 #define SWIGTYPE_p_eIDMW__PTEID_ExReaderSetChanged swig_types[33]
    2971 #define SWIGTYPE_p_eIDMW__PTEID_ExReleaseNeeded swig_types[34]
    2972 #define SWIGTYPE_p_eIDMW__PTEID_ExSOD swig_types[35]
    2973 #define SWIGTYPE_p_eIDMW__PTEID_ExUnknown swig_types[36]
    2974 #define SWIGTYPE_p_eIDMW__PTEID_ExUserMustAnswer swig_types[37]
    2975 #define SWIGTYPE_p_eIDMW__PTEID_Exception swig_types[38]
    2976 #define SWIGTYPE_p_eIDMW__PTEID_ID swig_types[39]
    2977 #define SWIGTYPE_p_eIDMW__PTEID_MemoryCard swig_types[40]
    2978 #define SWIGTYPE_p_eIDMW__PTEID_Object swig_types[41]
    2979 #define SWIGTYPE_p_eIDMW__PTEID_PDFSignature swig_types[42]
    2980 #define SWIGTYPE_p_eIDMW__PTEID_PIC swig_types[43]
    2981 #define SWIGTYPE_p_eIDMW__PTEID_Photo swig_types[44]
    2982 #define SWIGTYPE_p_eIDMW__PTEID_Pin swig_types[45]
    2983 #define SWIGTYPE_p_eIDMW__PTEID_Pins swig_types[46]
    2984 #define SWIGTYPE_p_eIDMW__PTEID_PublicKey swig_types[47]
    2985 #define SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey swig_types[48]
    2986 #define SWIGTYPE_p_eIDMW__PTEID_RawData_Eid swig_types[49]
    2987 #define SWIGTYPE_p_eIDMW__PTEID_ReaderContext swig_types[50]
    2988 #define SWIGTYPE_p_eIDMW__PTEID_ReaderSet swig_types[51]
    2989 #define SWIGTYPE_p_eIDMW__PTEID_SigVerifier swig_types[52]
    2990 #define SWIGTYPE_p_eIDMW__PTEID_SmartCard swig_types[53]
    2991 #define SWIGTYPE_p_eIDMW__PTEID_Sod swig_types[54]
    2992 #define SWIGTYPE_p_eIDMW__PTEID_TokenInfo swig_types[55]
    2993 #define SWIGTYPE_p_eIDMW__PTEID_XMLDoc swig_types[56]
    2994 #define SWIGTYPE_p_eIDMW__PTEID_XmlUserRequestedInfo swig_types[57]
    2995 #define SWIGTYPE_p_eIDMW__tCapPinChangeState swig_types[58]
    2996 #define SWIGTYPE_p_eIDMW__tCompCardType swig_types[59]
    2997 #define SWIGTYPE_p_eIDMW__tProxyInfo swig_types[60]
    2998 #define SWIGTYPE_p_f_enum_eIDMW__tCapPinChangeState__void swig_types[61]
    2999 #define SWIGTYPE_p_f_long_unsigned_long_p_void__void swig_types[62]
    3000 #define SWIGTYPE_p_f_p_void_int__void swig_types[63]
    3001 #define SWIGTYPE_p_long swig_types[64]
    3002 #define SWIGTYPE_p_p_char swig_types[65]
    3003 #define SWIGTYPE_p_unsigned_char swig_types[66]
    3004 #define SWIGTYPE_p_unsigned_long swig_types[67]
    3005 static swig_type_info *swig_types[69];
    3006 static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0};
     2938#define SWIGTYPE_p_eIDMW__PTEID_Address swig_types[1]
     2939#define SWIGTYPE_p_eIDMW__PTEID_Biometric swig_types[2]
     2940#define SWIGTYPE_p_eIDMW__PTEID_ByteArray swig_types[3]
     2941#define SWIGTYPE_p_eIDMW__PTEID_CCXML_Doc swig_types[4]
     2942#define SWIGTYPE_p_eIDMW__PTEID_Card swig_types[5]
     2943#define SWIGTYPE_p_eIDMW__PTEID_CardVersionInfo swig_types[6]
     2944#define SWIGTYPE_p_eIDMW__PTEID_Certificate swig_types[7]
     2945#define SWIGTYPE_p_eIDMW__PTEID_Certificates swig_types[8]
     2946#define SWIGTYPE_p_eIDMW__PTEID_Config swig_types[9]
     2947#define SWIGTYPE_p_eIDMW__PTEID_Crypto swig_types[10]
     2948#define SWIGTYPE_p_eIDMW__PTEID_EIDCard swig_types[11]
     2949#define SWIGTYPE_p_eIDMW__PTEID_EId swig_types[12]
     2950#define SWIGTYPE_p_eIDMW__PTEID_ExBadTransaction swig_types[13]
     2951#define SWIGTYPE_p_eIDMW__PTEID_ExBadUsage swig_types[14]
     2952#define SWIGTYPE_p_eIDMW__PTEID_ExCardBadType swig_types[15]
     2953#define SWIGTYPE_p_eIDMW__PTEID_ExCardChanged swig_types[16]
     2954#define SWIGTYPE_p_eIDMW__PTEID_ExCardTypeUnknown swig_types[17]
     2955#define SWIGTYPE_p_eIDMW__PTEID_ExCertNoIssuer swig_types[18]
     2956#define SWIGTYPE_p_eIDMW__PTEID_ExCertNoRoot swig_types[19]
     2957#define SWIGTYPE_p_eIDMW__PTEID_ExCmdNotAllowed swig_types[20]
     2958#define SWIGTYPE_p_eIDMW__PTEID_ExCmdNotSupported swig_types[21]
     2959#define SWIGTYPE_p_eIDMW__PTEID_ExDocTypeUnknown swig_types[22]
     2960#define SWIGTYPE_p_eIDMW__PTEID_ExFileTypeUnknown swig_types[23]
     2961#define SWIGTYPE_p_eIDMW__PTEID_ExNoCardPresent swig_types[24]
     2962#define SWIGTYPE_p_eIDMW__PTEID_ExNoReader swig_types[25]
     2963#define SWIGTYPE_p_eIDMW__PTEID_ExNotAllowByUser swig_types[26]
     2964#define SWIGTYPE_p_eIDMW__PTEID_ExParamRange swig_types[27]
     2965#define SWIGTYPE_p_eIDMW__PTEID_ExReaderSetChanged swig_types[28]
     2966#define SWIGTYPE_p_eIDMW__PTEID_ExReleaseNeeded swig_types[29]
     2967#define SWIGTYPE_p_eIDMW__PTEID_ExSOD swig_types[30]
     2968#define SWIGTYPE_p_eIDMW__PTEID_ExUnknown swig_types[31]
     2969#define SWIGTYPE_p_eIDMW__PTEID_ExUserMustAnswer swig_types[32]
     2970#define SWIGTYPE_p_eIDMW__PTEID_Exception swig_types[33]
     2971#define SWIGTYPE_p_eIDMW__PTEID_MemoryCard swig_types[34]
     2972#define SWIGTYPE_p_eIDMW__PTEID_Object swig_types[35]
     2973#define SWIGTYPE_p_eIDMW__PTEID_PDFSignature swig_types[36]
     2974#define SWIGTYPE_p_eIDMW__PTEID_Photo swig_types[37]
     2975#define SWIGTYPE_p_eIDMW__PTEID_Pin swig_types[38]
     2976#define SWIGTYPE_p_eIDMW__PTEID_Pins swig_types[39]
     2977#define SWIGTYPE_p_eIDMW__PTEID_PublicKey swig_types[40]
     2978#define SWIGTYPE_p_eIDMW__PTEID_RawData_Eid swig_types[41]
     2979#define SWIGTYPE_p_eIDMW__PTEID_ReaderContext swig_types[42]
     2980#define SWIGTYPE_p_eIDMW__PTEID_ReaderSet swig_types[43]
     2981#define SWIGTYPE_p_eIDMW__PTEID_SigVerifier swig_types[44]
     2982#define SWIGTYPE_p_eIDMW__PTEID_SmartCard swig_types[45]
     2983#define SWIGTYPE_p_eIDMW__PTEID_Sod swig_types[46]
     2984#define SWIGTYPE_p_eIDMW__PTEID_XMLDoc swig_types[47]
     2985#define SWIGTYPE_p_eIDMW__PTEID_XmlUserRequestedInfo swig_types[48]
     2986#define SWIGTYPE_p_f_long_unsigned_long_p_void__void swig_types[49]
     2987#define SWIGTYPE_p_f_p_void_int__void swig_types[50]
     2988#define SWIGTYPE_p_p_char swig_types[51]
     2989#define SWIGTYPE_p_unsigned_char swig_types[52]
     2990#define SWIGTYPE_p_unsigned_long swig_types[53]
     2991static swig_type_info *swig_types[55];
     2992static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
    30072993#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    30082994#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
     
    34943480}
    34953481
    3496 
    3497 SWIGINTERN int
    3498 SWIG_AsVal_short (PyObject * obj, short *val)
    3499 {
    3500   long v;
    3501   int res = SWIG_AsVal_long (obj, &v);
    3502   if (SWIG_IsOK(res)) {
    3503     if ((v < SHRT_MIN || v > SHRT_MAX)) {
    3504       return SWIG_OverflowError;
    3505     } else {
    3506       if (val) *val = static_cast< short >(v);
    3507     }
    3508   } 
    3509   return res;
    3510 }
    3511 
    3512 
    3513 SWIGINTERNINLINE PyObject *
    3514 SWIG_From_short  (short value)
    3515 {   
    3516   return SWIG_From_long  (value);
    3517 }
    3518 
    3519 
    3520 SWIGINTERN int
    3521 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
    3522 {
    3523   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
    3524   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
    3525   if (SWIG_IsOK(res)) {
    3526     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
    3527     if (csize <= size) {
    3528       if (val) {
    3529         if (csize) memcpy(val, cptr, csize*sizeof(char));
    3530         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
    3531       }
    3532       if (alloc == SWIG_NEWOBJ) {
    3533         delete[] cptr;
    3534         res = SWIG_DelNewMask(res);
    3535       }     
    3536       return res;
    3537     }
    3538     if (alloc == SWIG_NEWOBJ) delete[] cptr;
    3539   }
    3540   return SWIG_TypeError;
    3541 }
    3542 
    3543 
    3544 SWIGINTERN int
    3545 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
    3546 {
    3547   unsigned long v;
    3548   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    3549   if (SWIG_IsOK(res)) {
    3550     if ((v > UCHAR_MAX)) {
    3551       return SWIG_OverflowError;
    3552     } else {
    3553       if (val) *val = static_cast< unsigned char >(v);
    3554     }
    3555   } 
    3556   return res;
    3557 }
    3558 
    3559 
    3560 SWIGINTERNINLINE PyObject *
    3561 SWIG_From_unsigned_SS_char  (unsigned char value)
    3562 {   
    3563   return SWIG_From_unsigned_SS_long  (value);
    3564 }
    3565 
    3566 
    3567 SWIGINTERNINLINE PyObject*
    3568   SWIG_From_unsigned_SS_int  (unsigned int value)
    3569 {
    3570   return PyInt_FromSize_t((size_t) value);
    3571 }
    3572 
    35733482#ifdef __cplusplus
    35743483extern "C" {
     
    48374746  arg1 = reinterpret_cast< eIDMW::PTEID_ByteArray * >(argp1);
    48384747  result = (unsigned char *)((eIDMW::PTEID_ByteArray const *)arg1)->GetBytes();
    4839   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
     4748  {
     4749    resultobj = PyBytes_FromStringAndSize( (const char *)result, arg1->Size());
     4750  }
    48404751  return resultobj;
    48414752fail:
     
    1573715648  Py_XDECREF(varargs);
    1573815649  return resultobj;
    15739 }
    15740 
    15741 
    15742 SWIGINTERN PyObject *_wrap_PTEID_ID_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15743   PyObject *resultobj = 0;
    15744   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15745   short arg2 ;
    15746   void *argp1 = 0 ;
    15747   int res1 = 0 ;
    15748   short val2 ;
    15749   int ecode2 = 0 ;
    15750   PyObject * obj0 = 0 ;
    15751   PyObject * obj1 = 0 ;
    15752  
    15753   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_version_set",2,2,&obj0,&obj1)) SWIG_fail;
    15754   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15755   if (!SWIG_IsOK(res1)) {
    15756     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_version_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15757   }
    15758   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15759   ecode2 = SWIG_AsVal_short(obj1, &val2);
    15760   if (!SWIG_IsOK(ecode2)) {
    15761     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_ID_version_set" "', argument " "2"" of type '" "short""'");
    15762   }
    15763   arg2 = static_cast< short >(val2);
    15764   if (arg1) (arg1)->version = arg2;
    15765   resultobj = SWIG_Py_Void();
    15766   return resultobj;
    15767 fail:
    15768   return NULL;
    15769 }
    15770 
    15771 
    15772 SWIGINTERN PyObject *_wrap_PTEID_ID_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15773   PyObject *resultobj = 0;
    15774   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15775   void *argp1 = 0 ;
    15776   int res1 = 0 ;
    15777   PyObject * obj0 = 0 ;
    15778   short result;
    15779  
    15780   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_version_get",1,1,&obj0)) SWIG_fail;
    15781   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15782   if (!SWIG_IsOK(res1)) {
    15783     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_version_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15784   }
    15785   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15786   result = (short) ((arg1)->version);
    15787   resultobj = SWIG_From_short(static_cast< short >(result));
    15788   return resultobj;
    15789 fail:
    15790   return NULL;
    15791 }
    15792 
    15793 
    15794 SWIGINTERN PyObject *_wrap_PTEID_ID_deliveryEntity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15795   PyObject *resultobj = 0;
    15796   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15797   char *arg2 ;
    15798   void *argp1 = 0 ;
    15799   int res1 = 0 ;
    15800   char temp2[40+2] ;
    15801   int res2 ;
    15802   PyObject * obj0 = 0 ;
    15803   PyObject * obj1 = 0 ;
    15804  
    15805   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_deliveryEntity_set",2,2,&obj0,&obj1)) SWIG_fail;
    15806   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15807   if (!SWIG_IsOK(res1)) {
    15808     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_deliveryEntity_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15809   }
    15810   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15811   res2 = SWIG_AsCharArray(obj1, temp2, 40+2);
    15812   if (!SWIG_IsOK(res2)) {
    15813     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_deliveryEntity_set" "', argument " "2"" of type '" "char [40+2]""'");
    15814   }
    15815   arg2 = reinterpret_cast< char * >(temp2);
    15816   if (arg2) memcpy(arg1->deliveryEntity,arg2,40+2*sizeof(char));
    15817   else memset(arg1->deliveryEntity,0,40+2*sizeof(char));
    15818   resultobj = SWIG_Py_Void();
    15819   return resultobj;
    15820 fail:
    15821   return NULL;
    15822 }
    15823 
    15824 
    15825 SWIGINTERN PyObject *_wrap_PTEID_ID_deliveryEntity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15826   PyObject *resultobj = 0;
    15827   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15828   void *argp1 = 0 ;
    15829   int res1 = 0 ;
    15830   PyObject * obj0 = 0 ;
    15831   char *result = 0 ;
    15832  
    15833   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_deliveryEntity_get",1,1,&obj0)) SWIG_fail;
    15834   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15835   if (!SWIG_IsOK(res1)) {
    15836     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_deliveryEntity_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15837   }
    15838   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15839   result = (char *)(char *) ((arg1)->deliveryEntity);
    15840   {
    15841     size_t size = 40+2;
    15842    
    15843     while (size && (result[size - 1] == '\0')) --size;
    15844    
    15845     resultobj = SWIG_FromCharPtrAndSize(result, size);
    15846   }
    15847   return resultobj;
    15848 fail:
    15849   return NULL;
    15850 }
    15851 
    15852 
    15853 SWIGINTERN PyObject *_wrap_PTEID_ID_country_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15854   PyObject *resultobj = 0;
    15855   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15856   char *arg2 ;
    15857   void *argp1 = 0 ;
    15858   int res1 = 0 ;
    15859   char temp2[80+2] ;
    15860   int res2 ;
    15861   PyObject * obj0 = 0 ;
    15862   PyObject * obj1 = 0 ;
    15863  
    15864   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_country_set",2,2,&obj0,&obj1)) SWIG_fail;
    15865   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15866   if (!SWIG_IsOK(res1)) {
    15867     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_country_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15868   }
    15869   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15870   res2 = SWIG_AsCharArray(obj1, temp2, 80+2);
    15871   if (!SWIG_IsOK(res2)) {
    15872     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_country_set" "', argument " "2"" of type '" "char [80+2]""'");
    15873   }
    15874   arg2 = reinterpret_cast< char * >(temp2);
    15875   if (arg2) memcpy(arg1->country,arg2,80+2*sizeof(char));
    15876   else memset(arg1->country,0,80+2*sizeof(char));
    15877   resultobj = SWIG_Py_Void();
    15878   return resultobj;
    15879 fail:
    15880   return NULL;
    15881 }
    15882 
    15883 
    15884 SWIGINTERN PyObject *_wrap_PTEID_ID_country_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15885   PyObject *resultobj = 0;
    15886   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15887   void *argp1 = 0 ;
    15888   int res1 = 0 ;
    15889   PyObject * obj0 = 0 ;
    15890   char *result = 0 ;
    15891  
    15892   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_country_get",1,1,&obj0)) SWIG_fail;
    15893   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15894   if (!SWIG_IsOK(res1)) {
    15895     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_country_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15896   }
    15897   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15898   result = (char *)(char *) ((arg1)->country);
    15899   {
    15900     size_t size = 80+2;
    15901    
    15902     while (size && (result[size - 1] == '\0')) --size;
    15903    
    15904     resultobj = SWIG_FromCharPtrAndSize(result, size);
    15905   }
    15906   return resultobj;
    15907 fail:
    15908   return NULL;
    15909 }
    15910 
    15911 
    15912 SWIGINTERN PyObject *_wrap_PTEID_ID_documentType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15913   PyObject *resultobj = 0;
    15914   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15915   char *arg2 ;
    15916   void *argp1 = 0 ;
    15917   int res1 = 0 ;
    15918   char temp2[34+2] ;
    15919   int res2 ;
    15920   PyObject * obj0 = 0 ;
    15921   PyObject * obj1 = 0 ;
    15922  
    15923   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_documentType_set",2,2,&obj0,&obj1)) SWIG_fail;
    15924   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15925   if (!SWIG_IsOK(res1)) {
    15926     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_documentType_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15927   }
    15928   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15929   res2 = SWIG_AsCharArray(obj1, temp2, 34+2);
    15930   if (!SWIG_IsOK(res2)) {
    15931     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_documentType_set" "', argument " "2"" of type '" "char [34+2]""'");
    15932   }
    15933   arg2 = reinterpret_cast< char * >(temp2);
    15934   if (arg2) memcpy(arg1->documentType,arg2,34+2*sizeof(char));
    15935   else memset(arg1->documentType,0,34+2*sizeof(char));
    15936   resultobj = SWIG_Py_Void();
    15937   return resultobj;
    15938 fail:
    15939   return NULL;
    15940 }
    15941 
    15942 
    15943 SWIGINTERN PyObject *_wrap_PTEID_ID_documentType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15944   PyObject *resultobj = 0;
    15945   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15946   void *argp1 = 0 ;
    15947   int res1 = 0 ;
    15948   PyObject * obj0 = 0 ;
    15949   char *result = 0 ;
    15950  
    15951   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_documentType_get",1,1,&obj0)) SWIG_fail;
    15952   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15953   if (!SWIG_IsOK(res1)) {
    15954     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_documentType_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15955   }
    15956   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15957   result = (char *)(char *) ((arg1)->documentType);
    15958   {
    15959     size_t size = 34+2;
    15960    
    15961     while (size && (result[size - 1] == '\0')) --size;
    15962    
    15963     resultobj = SWIG_FromCharPtrAndSize(result, size);
    15964   }
    15965   return resultobj;
    15966 fail:
    15967   return NULL;
    15968 }
    15969 
    15970 
    15971 SWIGINTERN PyObject *_wrap_PTEID_ID_cardNumber_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    15972   PyObject *resultobj = 0;
    15973   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    15974   char *arg2 ;
    15975   void *argp1 = 0 ;
    15976   int res1 = 0 ;
    15977   char temp2[28+2] ;
    15978   int res2 ;
    15979   PyObject * obj0 = 0 ;
    15980   PyObject * obj1 = 0 ;
    15981  
    15982   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardNumber_set",2,2,&obj0,&obj1)) SWIG_fail;
    15983   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    15984   if (!SWIG_IsOK(res1)) {
    15985     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardNumber_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    15986   }
    15987   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    15988   res2 = SWIG_AsCharArray(obj1, temp2, 28+2);
    15989   if (!SWIG_IsOK(res2)) {
    15990     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_cardNumber_set" "', argument " "2"" of type '" "char [28+2]""'");
    15991   }
    15992   arg2 = reinterpret_cast< char * >(temp2);
    15993   if (arg2) memcpy(arg1->cardNumber,arg2,28+2*sizeof(char));
    15994   else memset(arg1->cardNumber,0,28+2*sizeof(char));
    15995   resultobj = SWIG_Py_Void();
    15996   return resultobj;
    15997 fail:
    15998   return NULL;
    15999 }
    16000 
    16001 
    16002 SWIGINTERN PyObject *_wrap_PTEID_ID_cardNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16003   PyObject *resultobj = 0;
    16004   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16005   void *argp1 = 0 ;
    16006   int res1 = 0 ;
    16007   PyObject * obj0 = 0 ;
    16008   char *result = 0 ;
    16009  
    16010   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardNumber_get",1,1,&obj0)) SWIG_fail;
    16011   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16012   if (!SWIG_IsOK(res1)) {
    16013     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardNumber_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16014   }
    16015   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16016   result = (char *)(char *) ((arg1)->cardNumber);
    16017   {
    16018     size_t size = 28+2;
    16019    
    16020     while (size && (result[size - 1] == '\0')) --size;
    16021    
    16022     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16023   }
    16024   return resultobj;
    16025 fail:
    16026   return NULL;
    16027 }
    16028 
    16029 
    16030 SWIGINTERN PyObject *_wrap_PTEID_ID_cardNumberPAN_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16031   PyObject *resultobj = 0;
    16032   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16033   char *arg2 ;
    16034   void *argp1 = 0 ;
    16035   int res1 = 0 ;
    16036   char temp2[32+2] ;
    16037   int res2 ;
    16038   PyObject * obj0 = 0 ;
    16039   PyObject * obj1 = 0 ;
    16040  
    16041   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardNumberPAN_set",2,2,&obj0,&obj1)) SWIG_fail;
    16042   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16043   if (!SWIG_IsOK(res1)) {
    16044     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardNumberPAN_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16045   }
    16046   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16047   res2 = SWIG_AsCharArray(obj1, temp2, 32+2);
    16048   if (!SWIG_IsOK(res2)) {
    16049     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_cardNumberPAN_set" "', argument " "2"" of type '" "char [32+2]""'");
    16050   }
    16051   arg2 = reinterpret_cast< char * >(temp2);
    16052   if (arg2) memcpy(arg1->cardNumberPAN,arg2,32+2*sizeof(char));
    16053   else memset(arg1->cardNumberPAN,0,32+2*sizeof(char));
    16054   resultobj = SWIG_Py_Void();
    16055   return resultobj;
    16056 fail:
    16057   return NULL;
    16058 }
    16059 
    16060 
    16061 SWIGINTERN PyObject *_wrap_PTEID_ID_cardNumberPAN_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16062   PyObject *resultobj = 0;
    16063   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16064   void *argp1 = 0 ;
    16065   int res1 = 0 ;
    16066   PyObject * obj0 = 0 ;
    16067   char *result = 0 ;
    16068  
    16069   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardNumberPAN_get",1,1,&obj0)) SWIG_fail;
    16070   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16071   if (!SWIG_IsOK(res1)) {
    16072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardNumberPAN_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16073   }
    16074   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16075   result = (char *)(char *) ((arg1)->cardNumberPAN);
    16076   {
    16077     size_t size = 32+2;
    16078    
    16079     while (size && (result[size - 1] == '\0')) --size;
    16080    
    16081     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16082   }
    16083   return resultobj;
    16084 fail:
    16085   return NULL;
    16086 }
    16087 
    16088 
    16089 SWIGINTERN PyObject *_wrap_PTEID_ID_cardVersion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16090   PyObject *resultobj = 0;
    16091   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16092   char *arg2 ;
    16093   void *argp1 = 0 ;
    16094   int res1 = 0 ;
    16095   char temp2[16+2] ;
    16096   int res2 ;
    16097   PyObject * obj0 = 0 ;
    16098   PyObject * obj1 = 0 ;
    16099  
    16100   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardVersion_set",2,2,&obj0,&obj1)) SWIG_fail;
    16101   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16102   if (!SWIG_IsOK(res1)) {
    16103     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardVersion_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16104   }
    16105   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16106   res2 = SWIG_AsCharArray(obj1, temp2, 16+2);
    16107   if (!SWIG_IsOK(res2)) {
    16108     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_cardVersion_set" "', argument " "2"" of type '" "char [16+2]""'");
    16109   }
    16110   arg2 = reinterpret_cast< char * >(temp2);
    16111   if (arg2) memcpy(arg1->cardVersion,arg2,16+2*sizeof(char));
    16112   else memset(arg1->cardVersion,0,16+2*sizeof(char));
    16113   resultobj = SWIG_Py_Void();
    16114   return resultobj;
    16115 fail:
    16116   return NULL;
    16117 }
    16118 
    16119 
    16120 SWIGINTERN PyObject *_wrap_PTEID_ID_cardVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16121   PyObject *resultobj = 0;
    16122   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16123   void *argp1 = 0 ;
    16124   int res1 = 0 ;
    16125   PyObject * obj0 = 0 ;
    16126   char *result = 0 ;
    16127  
    16128   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_cardVersion_get",1,1,&obj0)) SWIG_fail;
    16129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16130   if (!SWIG_IsOK(res1)) {
    16131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_cardVersion_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16132   }
    16133   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16134   result = (char *)(char *) ((arg1)->cardVersion);
    16135   {
    16136     size_t size = 16+2;
    16137    
    16138     while (size && (result[size - 1] == '\0')) --size;
    16139    
    16140     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16141   }
    16142   return resultobj;
    16143 fail:
    16144   return NULL;
    16145 }
    16146 
    16147 
    16148 SWIGINTERN PyObject *_wrap_PTEID_ID_deliveryDate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16149   PyObject *resultobj = 0;
    16150   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16151   char *arg2 ;
    16152   void *argp1 = 0 ;
    16153   int res1 = 0 ;
    16154   char temp2[20+2] ;
    16155   int res2 ;
    16156   PyObject * obj0 = 0 ;
    16157   PyObject * obj1 = 0 ;
    16158  
    16159   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_deliveryDate_set",2,2,&obj0,&obj1)) SWIG_fail;
    16160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16161   if (!SWIG_IsOK(res1)) {
    16162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_deliveryDate_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16163   }
    16164   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16165   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    16166   if (!SWIG_IsOK(res2)) {
    16167     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_deliveryDate_set" "', argument " "2"" of type '" "char [20+2]""'");
    16168   }
    16169   arg2 = reinterpret_cast< char * >(temp2);
    16170   if (arg2) memcpy(arg1->deliveryDate,arg2,20+2*sizeof(char));
    16171   else memset(arg1->deliveryDate,0,20+2*sizeof(char));
    16172   resultobj = SWIG_Py_Void();
    16173   return resultobj;
    16174 fail:
    16175   return NULL;
    16176 }
    16177 
    16178 
    16179 SWIGINTERN PyObject *_wrap_PTEID_ID_deliveryDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16180   PyObject *resultobj = 0;
    16181   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16182   void *argp1 = 0 ;
    16183   int res1 = 0 ;
    16184   PyObject * obj0 = 0 ;
    16185   char *result = 0 ;
    16186  
    16187   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_deliveryDate_get",1,1,&obj0)) SWIG_fail;
    16188   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16189   if (!SWIG_IsOK(res1)) {
    16190     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_deliveryDate_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16191   }
    16192   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16193   result = (char *)(char *) ((arg1)->deliveryDate);
    16194   {
    16195     size_t size = 20+2;
    16196    
    16197     while (size && (result[size - 1] == '\0')) --size;
    16198    
    16199     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16200   }
    16201   return resultobj;
    16202 fail:
    16203   return NULL;
    16204 }
    16205 
    16206 
    16207 SWIGINTERN PyObject *_wrap_PTEID_ID_locale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16208   PyObject *resultobj = 0;
    16209   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16210   char *arg2 ;
    16211   void *argp1 = 0 ;
    16212   int res1 = 0 ;
    16213   char temp2[60+2] ;
    16214   int res2 ;
    16215   PyObject * obj0 = 0 ;
    16216   PyObject * obj1 = 0 ;
    16217  
    16218   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_locale_set",2,2,&obj0,&obj1)) SWIG_fail;
    16219   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16220   if (!SWIG_IsOK(res1)) {
    16221     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_locale_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16222   }
    16223   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16224   res2 = SWIG_AsCharArray(obj1, temp2, 60+2);
    16225   if (!SWIG_IsOK(res2)) {
    16226     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_locale_set" "', argument " "2"" of type '" "char [60+2]""'");
    16227   }
    16228   arg2 = reinterpret_cast< char * >(temp2);
    16229   if (arg2) memcpy(arg1->locale,arg2,60+2*sizeof(char));
    16230   else memset(arg1->locale,0,60+2*sizeof(char));
    16231   resultobj = SWIG_Py_Void();
    16232   return resultobj;
    16233 fail:
    16234   return NULL;
    16235 }
    16236 
    16237 
    16238 SWIGINTERN PyObject *_wrap_PTEID_ID_locale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16239   PyObject *resultobj = 0;
    16240   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16241   void *argp1 = 0 ;
    16242   int res1 = 0 ;
    16243   PyObject * obj0 = 0 ;
    16244   char *result = 0 ;
    16245  
    16246   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_locale_get",1,1,&obj0)) SWIG_fail;
    16247   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16248   if (!SWIG_IsOK(res1)) {
    16249     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_locale_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16250   }
    16251   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16252   result = (char *)(char *) ((arg1)->locale);
    16253   {
    16254     size_t size = 60+2;
    16255    
    16256     while (size && (result[size - 1] == '\0')) --size;
    16257    
    16258     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16259   }
    16260   return resultobj;
    16261 fail:
    16262   return NULL;
    16263 }
    16264 
    16265 
    16266 SWIGINTERN PyObject *_wrap_PTEID_ID_validityDate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16267   PyObject *resultobj = 0;
    16268   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16269   char *arg2 ;
    16270   void *argp1 = 0 ;
    16271   int res1 = 0 ;
    16272   char temp2[20+2] ;
    16273   int res2 ;
    16274   PyObject * obj0 = 0 ;
    16275   PyObject * obj1 = 0 ;
    16276  
    16277   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_validityDate_set",2,2,&obj0,&obj1)) SWIG_fail;
    16278   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16279   if (!SWIG_IsOK(res1)) {
    16280     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_validityDate_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16281   }
    16282   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16283   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    16284   if (!SWIG_IsOK(res2)) {
    16285     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_validityDate_set" "', argument " "2"" of type '" "char [20+2]""'");
    16286   }
    16287   arg2 = reinterpret_cast< char * >(temp2);
    16288   if (arg2) memcpy(arg1->validityDate,arg2,20+2*sizeof(char));
    16289   else memset(arg1->validityDate,0,20+2*sizeof(char));
    16290   resultobj = SWIG_Py_Void();
    16291   return resultobj;
    16292 fail:
    16293   return NULL;
    16294 }
    16295 
    16296 
    16297 SWIGINTERN PyObject *_wrap_PTEID_ID_validityDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16298   PyObject *resultobj = 0;
    16299   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16300   void *argp1 = 0 ;
    16301   int res1 = 0 ;
    16302   PyObject * obj0 = 0 ;
    16303   char *result = 0 ;
    16304  
    16305   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_validityDate_get",1,1,&obj0)) SWIG_fail;
    16306   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16307   if (!SWIG_IsOK(res1)) {
    16308     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_validityDate_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16309   }
    16310   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16311   result = (char *)(char *) ((arg1)->validityDate);
    16312   {
    16313     size_t size = 20+2;
    16314    
    16315     while (size && (result[size - 1] == '\0')) --size;
    16316    
    16317     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16318   }
    16319   return resultobj;
    16320 fail:
    16321   return NULL;
    16322 }
    16323 
    16324 
    16325 SWIGINTERN PyObject *_wrap_PTEID_ID_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16326   PyObject *resultobj = 0;
    16327   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16328   char *arg2 ;
    16329   void *argp1 = 0 ;
    16330   int res1 = 0 ;
    16331   char temp2[120+2] ;
    16332   int res2 ;
    16333   PyObject * obj0 = 0 ;
    16334   PyObject * obj1 = 0 ;
    16335  
    16336   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_name_set",2,2,&obj0,&obj1)) SWIG_fail;
    16337   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16338   if (!SWIG_IsOK(res1)) {
    16339     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_name_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16340   }
    16341   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16342   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16343   if (!SWIG_IsOK(res2)) {
    16344     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_name_set" "', argument " "2"" of type '" "char [120+2]""'");
    16345   }
    16346   arg2 = reinterpret_cast< char * >(temp2);
    16347   if (arg2) memcpy(arg1->name,arg2,120+2*sizeof(char));
    16348   else memset(arg1->name,0,120+2*sizeof(char));
    16349   resultobj = SWIG_Py_Void();
    16350   return resultobj;
    16351 fail:
    16352   return NULL;
    16353 }
    16354 
    16355 
    16356 SWIGINTERN PyObject *_wrap_PTEID_ID_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16357   PyObject *resultobj = 0;
    16358   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16359   void *argp1 = 0 ;
    16360   int res1 = 0 ;
    16361   PyObject * obj0 = 0 ;
    16362   char *result = 0 ;
    16363  
    16364   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_name_get",1,1,&obj0)) SWIG_fail;
    16365   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16366   if (!SWIG_IsOK(res1)) {
    16367     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_name_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16368   }
    16369   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16370   result = (char *)(char *) ((arg1)->name);
    16371   {
    16372     size_t size = 120+2;
    16373    
    16374     while (size && (result[size - 1] == '\0')) --size;
    16375    
    16376     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16377   }
    16378   return resultobj;
    16379 fail:
    16380   return NULL;
    16381 }
    16382 
    16383 
    16384 SWIGINTERN PyObject *_wrap_PTEID_ID_firstname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16385   PyObject *resultobj = 0;
    16386   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16387   char *arg2 ;
    16388   void *argp1 = 0 ;
    16389   int res1 = 0 ;
    16390   char temp2[120+2] ;
    16391   int res2 ;
    16392   PyObject * obj0 = 0 ;
    16393   PyObject * obj1 = 0 ;
    16394  
    16395   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstname_set",2,2,&obj0,&obj1)) SWIG_fail;
    16396   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16397   if (!SWIG_IsOK(res1)) {
    16398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstname_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16399   }
    16400   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16401   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16402   if (!SWIG_IsOK(res2)) {
    16403     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_firstname_set" "', argument " "2"" of type '" "char [120+2]""'");
    16404   }
    16405   arg2 = reinterpret_cast< char * >(temp2);
    16406   if (arg2) memcpy(arg1->firstname,arg2,120+2*sizeof(char));
    16407   else memset(arg1->firstname,0,120+2*sizeof(char));
    16408   resultobj = SWIG_Py_Void();
    16409   return resultobj;
    16410 fail:
    16411   return NULL;
    16412 }
    16413 
    16414 
    16415 SWIGINTERN PyObject *_wrap_PTEID_ID_firstname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16416   PyObject *resultobj = 0;
    16417   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16418   void *argp1 = 0 ;
    16419   int res1 = 0 ;
    16420   PyObject * obj0 = 0 ;
    16421   char *result = 0 ;
    16422  
    16423   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstname_get",1,1,&obj0)) SWIG_fail;
    16424   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16425   if (!SWIG_IsOK(res1)) {
    16426     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstname_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16427   }
    16428   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16429   result = (char *)(char *) ((arg1)->firstname);
    16430   {
    16431     size_t size = 120+2;
    16432    
    16433     while (size && (result[size - 1] == '\0')) --size;
    16434    
    16435     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16436   }
    16437   return resultobj;
    16438 fail:
    16439   return NULL;
    16440 }
    16441 
    16442 
    16443 SWIGINTERN PyObject *_wrap_PTEID_ID_sex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16444   PyObject *resultobj = 0;
    16445   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16446   char *arg2 ;
    16447   void *argp1 = 0 ;
    16448   int res1 = 0 ;
    16449   char temp2[2+2] ;
    16450   int res2 ;
    16451   PyObject * obj0 = 0 ;
    16452   PyObject * obj1 = 0 ;
    16453  
    16454   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_sex_set",2,2,&obj0,&obj1)) SWIG_fail;
    16455   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16456   if (!SWIG_IsOK(res1)) {
    16457     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_sex_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16458   }
    16459   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16460   res2 = SWIG_AsCharArray(obj1, temp2, 2+2);
    16461   if (!SWIG_IsOK(res2)) {
    16462     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_sex_set" "', argument " "2"" of type '" "char [2+2]""'");
    16463   }
    16464   arg2 = reinterpret_cast< char * >(temp2);
    16465   if (arg2) memcpy(arg1->sex,arg2,2+2*sizeof(char));
    16466   else memset(arg1->sex,0,2+2*sizeof(char));
    16467   resultobj = SWIG_Py_Void();
    16468   return resultobj;
    16469 fail:
    16470   return NULL;
    16471 }
    16472 
    16473 
    16474 SWIGINTERN PyObject *_wrap_PTEID_ID_sex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16475   PyObject *resultobj = 0;
    16476   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16477   void *argp1 = 0 ;
    16478   int res1 = 0 ;
    16479   PyObject * obj0 = 0 ;
    16480   char *result = 0 ;
    16481  
    16482   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_sex_get",1,1,&obj0)) SWIG_fail;
    16483   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16484   if (!SWIG_IsOK(res1)) {
    16485     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_sex_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16486   }
    16487   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16488   result = (char *)(char *) ((arg1)->sex);
    16489   {
    16490     size_t size = 2+2;
    16491    
    16492     while (size && (result[size - 1] == '\0')) --size;
    16493    
    16494     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16495   }
    16496   return resultobj;
    16497 fail:
    16498   return NULL;
    16499 }
    16500 
    16501 
    16502 SWIGINTERN PyObject *_wrap_PTEID_ID_nationality_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16503   PyObject *resultobj = 0;
    16504   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16505   char *arg2 ;
    16506   void *argp1 = 0 ;
    16507   int res1 = 0 ;
    16508   char temp2[6+2] ;
    16509   int res2 ;
    16510   PyObject * obj0 = 0 ;
    16511   PyObject * obj1 = 0 ;
    16512  
    16513   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nationality_set",2,2,&obj0,&obj1)) SWIG_fail;
    16514   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16515   if (!SWIG_IsOK(res1)) {
    16516     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nationality_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16517   }
    16518   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16519   res2 = SWIG_AsCharArray(obj1, temp2, 6+2);
    16520   if (!SWIG_IsOK(res2)) {
    16521     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_nationality_set" "', argument " "2"" of type '" "char [6+2]""'");
    16522   }
    16523   arg2 = reinterpret_cast< char * >(temp2);
    16524   if (arg2) memcpy(arg1->nationality,arg2,6+2*sizeof(char));
    16525   else memset(arg1->nationality,0,6+2*sizeof(char));
    16526   resultobj = SWIG_Py_Void();
    16527   return resultobj;
    16528 fail:
    16529   return NULL;
    16530 }
    16531 
    16532 
    16533 SWIGINTERN PyObject *_wrap_PTEID_ID_nationality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16534   PyObject *resultobj = 0;
    16535   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16536   void *argp1 = 0 ;
    16537   int res1 = 0 ;
    16538   PyObject * obj0 = 0 ;
    16539   char *result = 0 ;
    16540  
    16541   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nationality_get",1,1,&obj0)) SWIG_fail;
    16542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16543   if (!SWIG_IsOK(res1)) {
    16544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nationality_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16545   }
    16546   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16547   result = (char *)(char *) ((arg1)->nationality);
    16548   {
    16549     size_t size = 6+2;
    16550    
    16551     while (size && (result[size - 1] == '\0')) --size;
    16552    
    16553     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16554   }
    16555   return resultobj;
    16556 fail:
    16557   return NULL;
    16558 }
    16559 
    16560 
    16561 SWIGINTERN PyObject *_wrap_PTEID_ID_birthDate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16562   PyObject *resultobj = 0;
    16563   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16564   char *arg2 ;
    16565   void *argp1 = 0 ;
    16566   int res1 = 0 ;
    16567   char temp2[20+2] ;
    16568   int res2 ;
    16569   PyObject * obj0 = 0 ;
    16570   PyObject * obj1 = 0 ;
    16571  
    16572   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_birthDate_set",2,2,&obj0,&obj1)) SWIG_fail;
    16573   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16574   if (!SWIG_IsOK(res1)) {
    16575     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_birthDate_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16576   }
    16577   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16578   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    16579   if (!SWIG_IsOK(res2)) {
    16580     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_birthDate_set" "', argument " "2"" of type '" "char [20+2]""'");
    16581   }
    16582   arg2 = reinterpret_cast< char * >(temp2);
    16583   if (arg2) memcpy(arg1->birthDate,arg2,20+2*sizeof(char));
    16584   else memset(arg1->birthDate,0,20+2*sizeof(char));
    16585   resultobj = SWIG_Py_Void();
    16586   return resultobj;
    16587 fail:
    16588   return NULL;
    16589 }
    16590 
    16591 
    16592 SWIGINTERN PyObject *_wrap_PTEID_ID_birthDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16593   PyObject *resultobj = 0;
    16594   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16595   void *argp1 = 0 ;
    16596   int res1 = 0 ;
    16597   PyObject * obj0 = 0 ;
    16598   char *result = 0 ;
    16599  
    16600   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_birthDate_get",1,1,&obj0)) SWIG_fail;
    16601   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16602   if (!SWIG_IsOK(res1)) {
    16603     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_birthDate_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16604   }
    16605   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16606   result = (char *)(char *) ((arg1)->birthDate);
    16607   {
    16608     size_t size = 20+2;
    16609    
    16610     while (size && (result[size - 1] == '\0')) --size;
    16611    
    16612     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16613   }
    16614   return resultobj;
    16615 fail:
    16616   return NULL;
    16617 }
    16618 
    16619 
    16620 SWIGINTERN PyObject *_wrap_PTEID_ID_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16621   PyObject *resultobj = 0;
    16622   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16623   char *arg2 ;
    16624   void *argp1 = 0 ;
    16625   int res1 = 0 ;
    16626   char temp2[8+2] ;
    16627   int res2 ;
    16628   PyObject * obj0 = 0 ;
    16629   PyObject * obj1 = 0 ;
    16630  
    16631   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_height_set",2,2,&obj0,&obj1)) SWIG_fail;
    16632   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16633   if (!SWIG_IsOK(res1)) {
    16634     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_height_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16635   }
    16636   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16637   res2 = SWIG_AsCharArray(obj1, temp2, 8+2);
    16638   if (!SWIG_IsOK(res2)) {
    16639     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_height_set" "', argument " "2"" of type '" "char [8+2]""'");
    16640   }
    16641   arg2 = reinterpret_cast< char * >(temp2);
    16642   if (arg2) memcpy(arg1->height,arg2,8+2*sizeof(char));
    16643   else memset(arg1->height,0,8+2*sizeof(char));
    16644   resultobj = SWIG_Py_Void();
    16645   return resultobj;
    16646 fail:
    16647   return NULL;
    16648 }
    16649 
    16650 
    16651 SWIGINTERN PyObject *_wrap_PTEID_ID_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16652   PyObject *resultobj = 0;
    16653   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16654   void *argp1 = 0 ;
    16655   int res1 = 0 ;
    16656   PyObject * obj0 = 0 ;
    16657   char *result = 0 ;
    16658  
    16659   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_height_get",1,1,&obj0)) SWIG_fail;
    16660   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16661   if (!SWIG_IsOK(res1)) {
    16662     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_height_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16663   }
    16664   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16665   result = (char *)(char *) ((arg1)->height);
    16666   {
    16667     size_t size = 8+2;
    16668    
    16669     while (size && (result[size - 1] == '\0')) --size;
    16670    
    16671     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16672   }
    16673   return resultobj;
    16674 fail:
    16675   return NULL;
    16676 }
    16677 
    16678 
    16679 SWIGINTERN PyObject *_wrap_PTEID_ID_numBI_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16680   PyObject *resultobj = 0;
    16681   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16682   char *arg2 ;
    16683   void *argp1 = 0 ;
    16684   int res1 = 0 ;
    16685   char temp2[18+2] ;
    16686   int res2 ;
    16687   PyObject * obj0 = 0 ;
    16688   PyObject * obj1 = 0 ;
    16689  
    16690   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numBI_set",2,2,&obj0,&obj1)) SWIG_fail;
    16691   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16692   if (!SWIG_IsOK(res1)) {
    16693     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numBI_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16694   }
    16695   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16696   res2 = SWIG_AsCharArray(obj1, temp2, 18+2);
    16697   if (!SWIG_IsOK(res2)) {
    16698     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_numBI_set" "', argument " "2"" of type '" "char [18+2]""'");
    16699   }
    16700   arg2 = reinterpret_cast< char * >(temp2);
    16701   if (arg2) memcpy(arg1->numBI,arg2,18+2*sizeof(char));
    16702   else memset(arg1->numBI,0,18+2*sizeof(char));
    16703   resultobj = SWIG_Py_Void();
    16704   return resultobj;
    16705 fail:
    16706   return NULL;
    16707 }
    16708 
    16709 
    16710 SWIGINTERN PyObject *_wrap_PTEID_ID_numBI_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16711   PyObject *resultobj = 0;
    16712   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16713   void *argp1 = 0 ;
    16714   int res1 = 0 ;
    16715   PyObject * obj0 = 0 ;
    16716   char *result = 0 ;
    16717  
    16718   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numBI_get",1,1,&obj0)) SWIG_fail;
    16719   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16720   if (!SWIG_IsOK(res1)) {
    16721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numBI_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16722   }
    16723   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16724   result = (char *)(char *) ((arg1)->numBI);
    16725   {
    16726     size_t size = 18+2;
    16727    
    16728     while (size && (result[size - 1] == '\0')) --size;
    16729    
    16730     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16731   }
    16732   return resultobj;
    16733 fail:
    16734   return NULL;
    16735 }
    16736 
    16737 
    16738 SWIGINTERN PyObject *_wrap_PTEID_ID_nameFather_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16739   PyObject *resultobj = 0;
    16740   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16741   char *arg2 ;
    16742   void *argp1 = 0 ;
    16743   int res1 = 0 ;
    16744   char temp2[120+2] ;
    16745   int res2 ;
    16746   PyObject * obj0 = 0 ;
    16747   PyObject * obj1 = 0 ;
    16748  
    16749   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nameFather_set",2,2,&obj0,&obj1)) SWIG_fail;
    16750   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16751   if (!SWIG_IsOK(res1)) {
    16752     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nameFather_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16753   }
    16754   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16755   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16756   if (!SWIG_IsOK(res2)) {
    16757     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_nameFather_set" "', argument " "2"" of type '" "char [120+2]""'");
    16758   }
    16759   arg2 = reinterpret_cast< char * >(temp2);
    16760   if (arg2) memcpy(arg1->nameFather,arg2,120+2*sizeof(char));
    16761   else memset(arg1->nameFather,0,120+2*sizeof(char));
    16762   resultobj = SWIG_Py_Void();
    16763   return resultobj;
    16764 fail:
    16765   return NULL;
    16766 }
    16767 
    16768 
    16769 SWIGINTERN PyObject *_wrap_PTEID_ID_nameFather_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16770   PyObject *resultobj = 0;
    16771   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16772   void *argp1 = 0 ;
    16773   int res1 = 0 ;
    16774   PyObject * obj0 = 0 ;
    16775   char *result = 0 ;
    16776  
    16777   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nameFather_get",1,1,&obj0)) SWIG_fail;
    16778   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16779   if (!SWIG_IsOK(res1)) {
    16780     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nameFather_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16781   }
    16782   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16783   result = (char *)(char *) ((arg1)->nameFather);
    16784   {
    16785     size_t size = 120+2;
    16786    
    16787     while (size && (result[size - 1] == '\0')) --size;
    16788    
    16789     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16790   }
    16791   return resultobj;
    16792 fail:
    16793   return NULL;
    16794 }
    16795 
    16796 
    16797 SWIGINTERN PyObject *_wrap_PTEID_ID_firstnameFather_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16798   PyObject *resultobj = 0;
    16799   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16800   char *arg2 ;
    16801   void *argp1 = 0 ;
    16802   int res1 = 0 ;
    16803   char temp2[120+2] ;
    16804   int res2 ;
    16805   PyObject * obj0 = 0 ;
    16806   PyObject * obj1 = 0 ;
    16807  
    16808   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstnameFather_set",2,2,&obj0,&obj1)) SWIG_fail;
    16809   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16810   if (!SWIG_IsOK(res1)) {
    16811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstnameFather_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16812   }
    16813   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16814   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16815   if (!SWIG_IsOK(res2)) {
    16816     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_firstnameFather_set" "', argument " "2"" of type '" "char [120+2]""'");
    16817   }
    16818   arg2 = reinterpret_cast< char * >(temp2);
    16819   if (arg2) memcpy(arg1->firstnameFather,arg2,120+2*sizeof(char));
    16820   else memset(arg1->firstnameFather,0,120+2*sizeof(char));
    16821   resultobj = SWIG_Py_Void();
    16822   return resultobj;
    16823 fail:
    16824   return NULL;
    16825 }
    16826 
    16827 
    16828 SWIGINTERN PyObject *_wrap_PTEID_ID_firstnameFather_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16829   PyObject *resultobj = 0;
    16830   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16831   void *argp1 = 0 ;
    16832   int res1 = 0 ;
    16833   PyObject * obj0 = 0 ;
    16834   char *result = 0 ;
    16835  
    16836   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstnameFather_get",1,1,&obj0)) SWIG_fail;
    16837   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16838   if (!SWIG_IsOK(res1)) {
    16839     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstnameFather_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16840   }
    16841   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16842   result = (char *)(char *) ((arg1)->firstnameFather);
    16843   {
    16844     size_t size = 120+2;
    16845    
    16846     while (size && (result[size - 1] == '\0')) --size;
    16847    
    16848     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16849   }
    16850   return resultobj;
    16851 fail:
    16852   return NULL;
    16853 }
    16854 
    16855 
    16856 SWIGINTERN PyObject *_wrap_PTEID_ID_nameMother_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16857   PyObject *resultobj = 0;
    16858   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16859   char *arg2 ;
    16860   void *argp1 = 0 ;
    16861   int res1 = 0 ;
    16862   char temp2[120+2] ;
    16863   int res2 ;
    16864   PyObject * obj0 = 0 ;
    16865   PyObject * obj1 = 0 ;
    16866  
    16867   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nameMother_set",2,2,&obj0,&obj1)) SWIG_fail;
    16868   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16869   if (!SWIG_IsOK(res1)) {
    16870     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nameMother_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16871   }
    16872   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16873   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16874   if (!SWIG_IsOK(res2)) {
    16875     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_nameMother_set" "', argument " "2"" of type '" "char [120+2]""'");
    16876   }
    16877   arg2 = reinterpret_cast< char * >(temp2);
    16878   if (arg2) memcpy(arg1->nameMother,arg2,120+2*sizeof(char));
    16879   else memset(arg1->nameMother,0,120+2*sizeof(char));
    16880   resultobj = SWIG_Py_Void();
    16881   return resultobj;
    16882 fail:
    16883   return NULL;
    16884 }
    16885 
    16886 
    16887 SWIGINTERN PyObject *_wrap_PTEID_ID_nameMother_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16888   PyObject *resultobj = 0;
    16889   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16890   void *argp1 = 0 ;
    16891   int res1 = 0 ;
    16892   PyObject * obj0 = 0 ;
    16893   char *result = 0 ;
    16894  
    16895   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_nameMother_get",1,1,&obj0)) SWIG_fail;
    16896   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16897   if (!SWIG_IsOK(res1)) {
    16898     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_nameMother_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16899   }
    16900   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16901   result = (char *)(char *) ((arg1)->nameMother);
    16902   {
    16903     size_t size = 120+2;
    16904    
    16905     while (size && (result[size - 1] == '\0')) --size;
    16906    
    16907     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16908   }
    16909   return resultobj;
    16910 fail:
    16911   return NULL;
    16912 }
    16913 
    16914 
    16915 SWIGINTERN PyObject *_wrap_PTEID_ID_firstnameMother_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16916   PyObject *resultobj = 0;
    16917   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16918   char *arg2 ;
    16919   void *argp1 = 0 ;
    16920   int res1 = 0 ;
    16921   char temp2[120+2] ;
    16922   int res2 ;
    16923   PyObject * obj0 = 0 ;
    16924   PyObject * obj1 = 0 ;
    16925  
    16926   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstnameMother_set",2,2,&obj0,&obj1)) SWIG_fail;
    16927   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16928   if (!SWIG_IsOK(res1)) {
    16929     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstnameMother_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16930   }
    16931   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16932   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    16933   if (!SWIG_IsOK(res2)) {
    16934     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_firstnameMother_set" "', argument " "2"" of type '" "char [120+2]""'");
    16935   }
    16936   arg2 = reinterpret_cast< char * >(temp2);
    16937   if (arg2) memcpy(arg1->firstnameMother,arg2,120+2*sizeof(char));
    16938   else memset(arg1->firstnameMother,0,120+2*sizeof(char));
    16939   resultobj = SWIG_Py_Void();
    16940   return resultobj;
    16941 fail:
    16942   return NULL;
    16943 }
    16944 
    16945 
    16946 SWIGINTERN PyObject *_wrap_PTEID_ID_firstnameMother_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16947   PyObject *resultobj = 0;
    16948   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16949   void *argp1 = 0 ;
    16950   int res1 = 0 ;
    16951   PyObject * obj0 = 0 ;
    16952   char *result = 0 ;
    16953  
    16954   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_firstnameMother_get",1,1,&obj0)) SWIG_fail;
    16955   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16956   if (!SWIG_IsOK(res1)) {
    16957     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_firstnameMother_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16958   }
    16959   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16960   result = (char *)(char *) ((arg1)->firstnameMother);
    16961   {
    16962     size_t size = 120+2;
    16963    
    16964     while (size && (result[size - 1] == '\0')) --size;
    16965    
    16966     resultobj = SWIG_FromCharPtrAndSize(result, size);
    16967   }
    16968   return resultobj;
    16969 fail:
    16970   return NULL;
    16971 }
    16972 
    16973 
    16974 SWIGINTERN PyObject *_wrap_PTEID_ID_numNIF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    16975   PyObject *resultobj = 0;
    16976   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    16977   char *arg2 ;
    16978   void *argp1 = 0 ;
    16979   int res1 = 0 ;
    16980   char temp2[18+2] ;
    16981   int res2 ;
    16982   PyObject * obj0 = 0 ;
    16983   PyObject * obj1 = 0 ;
    16984  
    16985   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numNIF_set",2,2,&obj0,&obj1)) SWIG_fail;
    16986   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    16987   if (!SWIG_IsOK(res1)) {
    16988     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numNIF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    16989   }
    16990   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    16991   res2 = SWIG_AsCharArray(obj1, temp2, 18+2);
    16992   if (!SWIG_IsOK(res2)) {
    16993     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_numNIF_set" "', argument " "2"" of type '" "char [18+2]""'");
    16994   }
    16995   arg2 = reinterpret_cast< char * >(temp2);
    16996   if (arg2) memcpy(arg1->numNIF,arg2,18+2*sizeof(char));
    16997   else memset(arg1->numNIF,0,18+2*sizeof(char));
    16998   resultobj = SWIG_Py_Void();
    16999   return resultobj;
    17000 fail:
    17001   return NULL;
    17002 }
    17003 
    17004 
    17005 SWIGINTERN PyObject *_wrap_PTEID_ID_numNIF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17006   PyObject *resultobj = 0;
    17007   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17008   void *argp1 = 0 ;
    17009   int res1 = 0 ;
    17010   PyObject * obj0 = 0 ;
    17011   char *result = 0 ;
    17012  
    17013   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numNIF_get",1,1,&obj0)) SWIG_fail;
    17014   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17015   if (!SWIG_IsOK(res1)) {
    17016     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numNIF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17017   }
    17018   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17019   result = (char *)(char *) ((arg1)->numNIF);
    17020   {
    17021     size_t size = 18+2;
    17022    
    17023     while (size && (result[size - 1] == '\0')) --size;
    17024    
    17025     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17026   }
    17027   return resultobj;
    17028 fail:
    17029   return NULL;
    17030 }
    17031 
    17032 
    17033 SWIGINTERN PyObject *_wrap_PTEID_ID_numSS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17034   PyObject *resultobj = 0;
    17035   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17036   char *arg2 ;
    17037   void *argp1 = 0 ;
    17038   int res1 = 0 ;
    17039   char temp2[22+2] ;
    17040   int res2 ;
    17041   PyObject * obj0 = 0 ;
    17042   PyObject * obj1 = 0 ;
    17043  
    17044   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numSS_set",2,2,&obj0,&obj1)) SWIG_fail;
    17045   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17046   if (!SWIG_IsOK(res1)) {
    17047     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numSS_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17048   }
    17049   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17050   res2 = SWIG_AsCharArray(obj1, temp2, 22+2);
    17051   if (!SWIG_IsOK(res2)) {
    17052     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_numSS_set" "', argument " "2"" of type '" "char [22+2]""'");
    17053   }
    17054   arg2 = reinterpret_cast< char * >(temp2);
    17055   if (arg2) memcpy(arg1->numSS,arg2,22+2*sizeof(char));
    17056   else memset(arg1->numSS,0,22+2*sizeof(char));
    17057   resultobj = SWIG_Py_Void();
    17058   return resultobj;
    17059 fail:
    17060   return NULL;
    17061 }
    17062 
    17063 
    17064 SWIGINTERN PyObject *_wrap_PTEID_ID_numSS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17065   PyObject *resultobj = 0;
    17066   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17067   void *argp1 = 0 ;
    17068   int res1 = 0 ;
    17069   PyObject * obj0 = 0 ;
    17070   char *result = 0 ;
    17071  
    17072   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numSS_get",1,1,&obj0)) SWIG_fail;
    17073   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17074   if (!SWIG_IsOK(res1)) {
    17075     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numSS_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17076   }
    17077   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17078   result = (char *)(char *) ((arg1)->numSS);
    17079   {
    17080     size_t size = 22+2;
    17081    
    17082     while (size && (result[size - 1] == '\0')) --size;
    17083    
    17084     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17085   }
    17086   return resultobj;
    17087 fail:
    17088   return NULL;
    17089 }
    17090 
    17091 
    17092 SWIGINTERN PyObject *_wrap_PTEID_ID_numSNS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17093   PyObject *resultobj = 0;
    17094   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17095   char *arg2 ;
    17096   void *argp1 = 0 ;
    17097   int res1 = 0 ;
    17098   char temp2[18+2] ;
    17099   int res2 ;
    17100   PyObject * obj0 = 0 ;
    17101   PyObject * obj1 = 0 ;
    17102  
    17103   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numSNS_set",2,2,&obj0,&obj1)) SWIG_fail;
    17104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17105   if (!SWIG_IsOK(res1)) {
    17106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numSNS_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17107   }
    17108   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17109   res2 = SWIG_AsCharArray(obj1, temp2, 18+2);
    17110   if (!SWIG_IsOK(res2)) {
    17111     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_numSNS_set" "', argument " "2"" of type '" "char [18+2]""'");
    17112   }
    17113   arg2 = reinterpret_cast< char * >(temp2);
    17114   if (arg2) memcpy(arg1->numSNS,arg2,18+2*sizeof(char));
    17115   else memset(arg1->numSNS,0,18+2*sizeof(char));
    17116   resultobj = SWIG_Py_Void();
    17117   return resultobj;
    17118 fail:
    17119   return NULL;
    17120 }
    17121 
    17122 
    17123 SWIGINTERN PyObject *_wrap_PTEID_ID_numSNS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17124   PyObject *resultobj = 0;
    17125   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17126   void *argp1 = 0 ;
    17127   int res1 = 0 ;
    17128   PyObject * obj0 = 0 ;
    17129   char *result = 0 ;
    17130  
    17131   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_numSNS_get",1,1,&obj0)) SWIG_fail;
    17132   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17133   if (!SWIG_IsOK(res1)) {
    17134     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_numSNS_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17135   }
    17136   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17137   result = (char *)(char *) ((arg1)->numSNS);
    17138   {
    17139     size_t size = 18+2;
    17140    
    17141     while (size && (result[size - 1] == '\0')) --size;
    17142    
    17143     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17144   }
    17145   return resultobj;
    17146 fail:
    17147   return NULL;
    17148 }
    17149 
    17150 
    17151 SWIGINTERN PyObject *_wrap_PTEID_ID_notes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17152   PyObject *resultobj = 0;
    17153   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17154   char *arg2 ;
    17155   void *argp1 = 0 ;
    17156   int res1 = 0 ;
    17157   char temp2[120+2] ;
    17158   int res2 ;
    17159   PyObject * obj0 = 0 ;
    17160   PyObject * obj1 = 0 ;
    17161  
    17162   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_notes_set",2,2,&obj0,&obj1)) SWIG_fail;
    17163   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17164   if (!SWIG_IsOK(res1)) {
    17165     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_notes_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17166   }
    17167   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17168   res2 = SWIG_AsCharArray(obj1, temp2, 120+2);
    17169   if (!SWIG_IsOK(res2)) {
    17170     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_notes_set" "', argument " "2"" of type '" "char [120+2]""'");
    17171   }
    17172   arg2 = reinterpret_cast< char * >(temp2);
    17173   if (arg2) memcpy(arg1->notes,arg2,120+2*sizeof(char));
    17174   else memset(arg1->notes,0,120+2*sizeof(char));
    17175   resultobj = SWIG_Py_Void();
    17176   return resultobj;
    17177 fail:
    17178   return NULL;
    17179 }
    17180 
    17181 
    17182 SWIGINTERN PyObject *_wrap_PTEID_ID_notes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17183   PyObject *resultobj = 0;
    17184   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17185   void *argp1 = 0 ;
    17186   int res1 = 0 ;
    17187   PyObject * obj0 = 0 ;
    17188   char *result = 0 ;
    17189  
    17190   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_notes_get",1,1,&obj0)) SWIG_fail;
    17191   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17192   if (!SWIG_IsOK(res1)) {
    17193     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_notes_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17194   }
    17195   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17196   result = (char *)(char *) ((arg1)->notes);
    17197   {
    17198     size_t size = 120+2;
    17199    
    17200     while (size && (result[size - 1] == '\0')) --size;
    17201    
    17202     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17203   }
    17204   return resultobj;
    17205 fail:
    17206   return NULL;
    17207 }
    17208 
    17209 
    17210 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17211   PyObject *resultobj = 0;
    17212   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17213   char *arg2 ;
    17214   void *argp1 = 0 ;
    17215   int res1 = 0 ;
    17216   char temp2[30+2] ;
    17217   int res2 ;
    17218   PyObject * obj0 = 0 ;
    17219   PyObject * obj1 = 0 ;
    17220  
    17221   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz1_set",2,2,&obj0,&obj1)) SWIG_fail;
    17222   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17223   if (!SWIG_IsOK(res1)) {
    17224     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz1_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17225   }
    17226   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17227   res2 = SWIG_AsCharArray(obj1, temp2, 30+2);
    17228   if (!SWIG_IsOK(res2)) {
    17229     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_mrz1_set" "', argument " "2"" of type '" "char [30+2]""'");
    17230   }
    17231   arg2 = reinterpret_cast< char * >(temp2);
    17232   if (arg2) memcpy(arg1->mrz1,arg2,30+2*sizeof(char));
    17233   else memset(arg1->mrz1,0,30+2*sizeof(char));
    17234   resultobj = SWIG_Py_Void();
    17235   return resultobj;
    17236 fail:
    17237   return NULL;
    17238 }
    17239 
    17240 
    17241 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17242   PyObject *resultobj = 0;
    17243   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17244   void *argp1 = 0 ;
    17245   int res1 = 0 ;
    17246   PyObject * obj0 = 0 ;
    17247   char *result = 0 ;
    17248  
    17249   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz1_get",1,1,&obj0)) SWIG_fail;
    17250   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17251   if (!SWIG_IsOK(res1)) {
    17252     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz1_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17253   }
    17254   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17255   result = (char *)(char *) ((arg1)->mrz1);
    17256   {
    17257     size_t size = 30+2;
    17258    
    17259     while (size && (result[size - 1] == '\0')) --size;
    17260    
    17261     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17262   }
    17263   return resultobj;
    17264 fail:
    17265   return NULL;
    17266 }
    17267 
    17268 
    17269 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17270   PyObject *resultobj = 0;
    17271   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17272   char *arg2 ;
    17273   void *argp1 = 0 ;
    17274   int res1 = 0 ;
    17275   char temp2[30+2] ;
    17276   int res2 ;
    17277   PyObject * obj0 = 0 ;
    17278   PyObject * obj1 = 0 ;
    17279  
    17280   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz2_set",2,2,&obj0,&obj1)) SWIG_fail;
    17281   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17282   if (!SWIG_IsOK(res1)) {
    17283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz2_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17284   }
    17285   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17286   res2 = SWIG_AsCharArray(obj1, temp2, 30+2);
    17287   if (!SWIG_IsOK(res2)) {
    17288     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_mrz2_set" "', argument " "2"" of type '" "char [30+2]""'");
    17289   }
    17290   arg2 = reinterpret_cast< char * >(temp2);
    17291   if (arg2) memcpy(arg1->mrz2,arg2,30+2*sizeof(char));
    17292   else memset(arg1->mrz2,0,30+2*sizeof(char));
    17293   resultobj = SWIG_Py_Void();
    17294   return resultobj;
    17295 fail:
    17296   return NULL;
    17297 }
    17298 
    17299 
    17300 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17301   PyObject *resultobj = 0;
    17302   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17303   void *argp1 = 0 ;
    17304   int res1 = 0 ;
    17305   PyObject * obj0 = 0 ;
    17306   char *result = 0 ;
    17307  
    17308   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz2_get",1,1,&obj0)) SWIG_fail;
    17309   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17310   if (!SWIG_IsOK(res1)) {
    17311     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz2_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17312   }
    17313   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17314   result = (char *)(char *) ((arg1)->mrz2);
    17315   {
    17316     size_t size = 30+2;
    17317    
    17318     while (size && (result[size - 1] == '\0')) --size;
    17319    
    17320     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17321   }
    17322   return resultobj;
    17323 fail:
    17324   return NULL;
    17325 }
    17326 
    17327 
    17328 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17329   PyObject *resultobj = 0;
    17330   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17331   char *arg2 ;
    17332   void *argp1 = 0 ;
    17333   int res1 = 0 ;
    17334   char temp2[30+2] ;
    17335   int res2 ;
    17336   PyObject * obj0 = 0 ;
    17337   PyObject * obj1 = 0 ;
    17338  
    17339   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz3_set",2,2,&obj0,&obj1)) SWIG_fail;
    17340   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17341   if (!SWIG_IsOK(res1)) {
    17342     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz3_set" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17343   }
    17344   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17345   res2 = SWIG_AsCharArray(obj1, temp2, 30+2);
    17346   if (!SWIG_IsOK(res2)) {
    17347     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ID_mrz3_set" "', argument " "2"" of type '" "char [30+2]""'");
    17348   }
    17349   arg2 = reinterpret_cast< char * >(temp2);
    17350   if (arg2) memcpy(arg1->mrz3,arg2,30+2*sizeof(char));
    17351   else memset(arg1->mrz3,0,30+2*sizeof(char));
    17352   resultobj = SWIG_Py_Void();
    17353   return resultobj;
    17354 fail:
    17355   return NULL;
    17356 }
    17357 
    17358 
    17359 SWIGINTERN PyObject *_wrap_PTEID_ID_mrz3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17360   PyObject *resultobj = 0;
    17361   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17362   void *argp1 = 0 ;
    17363   int res1 = 0 ;
    17364   PyObject * obj0 = 0 ;
    17365   char *result = 0 ;
    17366  
    17367   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ID_mrz3_get",1,1,&obj0)) SWIG_fail;
    17368   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    17369   if (!SWIG_IsOK(res1)) {
    17370     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ID_mrz3_get" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17371   }
    17372   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17373   result = (char *)(char *) ((arg1)->mrz3);
    17374   {
    17375     size_t size = 30+2;
    17376    
    17377     while (size && (result[size - 1] == '\0')) --size;
    17378    
    17379     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17380   }
    17381   return resultobj;
    17382 fail:
    17383   return NULL;
    17384 }
    17385 
    17386 
    17387 SWIGINTERN PyObject *_wrap_new_PTEID_ID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17388   PyObject *resultobj = 0;
    17389   eIDMW::PTEID_ID *result = 0 ;
    17390  
    17391   result = (eIDMW::PTEID_ID *)new eIDMW::PTEID_ID();
    17392   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_ID, SWIG_POINTER_NEW |  0 );
    17393   return resultobj;
    17394 fail:
    17395   return NULL;
    17396 }
    17397 
    17398 
    17399 SWIGINTERN PyObject *_wrap_delete_PTEID_ID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17400   PyObject *resultobj = 0;
    17401   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    17402   void *argp1 = 0 ;
    17403   int res1 = 0 ;
    17404   PyObject * obj0 = 0 ;
    17405  
    17406   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_ID",1,1,&obj0)) SWIG_fail;
    17407   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, SWIG_POINTER_DISOWN |  0 );
    17408   if (!SWIG_IsOK(res1)) {
    17409     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_ID" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    17410   }
    17411   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    17412   delete arg1;
    17413   resultobj = SWIG_Py_Void();
    17414   return resultobj;
    17415 fail:
    17416   return NULL;
    17417 }
    17418 
    17419 
    17420 SWIGINTERN PyObject *PTEID_ID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17421   PyObject *obj;
    17422   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    17423   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_ID, SWIG_NewClientData(obj));
    17424   return SWIG_Py_Void();
    17425 }
    17426 
    17427 SWIGINTERN PyObject *_wrap_PTEID_ADDR_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17428   PyObject *resultobj = 0;
    17429   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17430   short arg2 ;
    17431   void *argp1 = 0 ;
    17432   int res1 = 0 ;
    17433   short val2 ;
    17434   int ecode2 = 0 ;
    17435   PyObject * obj0 = 0 ;
    17436   PyObject * obj1 = 0 ;
    17437  
    17438   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_version_set",2,2,&obj0,&obj1)) SWIG_fail;
    17439   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17440   if (!SWIG_IsOK(res1)) {
    17441     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_version_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17442   }
    17443   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17444   ecode2 = SWIG_AsVal_short(obj1, &val2);
    17445   if (!SWIG_IsOK(ecode2)) {
    17446     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_ADDR_version_set" "', argument " "2"" of type '" "short""'");
    17447   }
    17448   arg2 = static_cast< short >(val2);
    17449   if (arg1) (arg1)->version = arg2;
    17450   resultobj = SWIG_Py_Void();
    17451   return resultobj;
    17452 fail:
    17453   return NULL;
    17454 }
    17455 
    17456 
    17457 SWIGINTERN PyObject *_wrap_PTEID_ADDR_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17458   PyObject *resultobj = 0;
    17459   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17460   void *argp1 = 0 ;
    17461   int res1 = 0 ;
    17462   PyObject * obj0 = 0 ;
    17463   short result;
    17464  
    17465   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_version_get",1,1,&obj0)) SWIG_fail;
    17466   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17467   if (!SWIG_IsOK(res1)) {
    17468     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_version_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17469   }
    17470   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17471   result = (short) ((arg1)->version);
    17472   resultobj = SWIG_From_short(static_cast< short >(result));
    17473   return resultobj;
    17474 fail:
    17475   return NULL;
    17476 }
    17477 
    17478 
    17479 SWIGINTERN PyObject *_wrap_PTEID_ADDR_addrType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17480   PyObject *resultobj = 0;
    17481   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17482   char *arg2 ;
    17483   void *argp1 = 0 ;
    17484   int res1 = 0 ;
    17485   char temp2[2+2] ;
    17486   int res2 ;
    17487   PyObject * obj0 = 0 ;
    17488   PyObject * obj1 = 0 ;
    17489  
    17490   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_addrType_set",2,2,&obj0,&obj1)) SWIG_fail;
    17491   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17492   if (!SWIG_IsOK(res1)) {
    17493     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_addrType_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17494   }
    17495   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17496   res2 = SWIG_AsCharArray(obj1, temp2, 2+2);
    17497   if (!SWIG_IsOK(res2)) {
    17498     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_addrType_set" "', argument " "2"" of type '" "char [2+2]""'");
    17499   }
    17500   arg2 = reinterpret_cast< char * >(temp2);
    17501   if (arg2) memcpy(arg1->addrType,arg2,2+2*sizeof(char));
    17502   else memset(arg1->addrType,0,2+2*sizeof(char));
    17503   resultobj = SWIG_Py_Void();
    17504   return resultobj;
    17505 fail:
    17506   return NULL;
    17507 }
    17508 
    17509 
    17510 SWIGINTERN PyObject *_wrap_PTEID_ADDR_addrType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17511   PyObject *resultobj = 0;
    17512   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17513   void *argp1 = 0 ;
    17514   int res1 = 0 ;
    17515   PyObject * obj0 = 0 ;
    17516   char *result = 0 ;
    17517  
    17518   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_addrType_get",1,1,&obj0)) SWIG_fail;
    17519   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17520   if (!SWIG_IsOK(res1)) {
    17521     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_addrType_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17522   }
    17523   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17524   result = (char *)(char *) ((arg1)->addrType);
    17525   {
    17526     size_t size = 2+2;
    17527    
    17528     while (size && (result[size - 1] == '\0')) --size;
    17529    
    17530     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17531   }
    17532   return resultobj;
    17533 fail:
    17534   return NULL;
    17535 }
    17536 
    17537 
    17538 SWIGINTERN PyObject *_wrap_PTEID_ADDR_country_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17539   PyObject *resultobj = 0;
    17540   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17541   char *arg2 ;
    17542   void *argp1 = 0 ;
    17543   int res1 = 0 ;
    17544   char temp2[4+2] ;
    17545   int res2 ;
    17546   PyObject * obj0 = 0 ;
    17547   PyObject * obj1 = 0 ;
    17548  
    17549   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_country_set",2,2,&obj0,&obj1)) SWIG_fail;
    17550   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17551   if (!SWIG_IsOK(res1)) {
    17552     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_country_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17553   }
    17554   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17555   res2 = SWIG_AsCharArray(obj1, temp2, 4+2);
    17556   if (!SWIG_IsOK(res2)) {
    17557     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_country_set" "', argument " "2"" of type '" "char [4+2]""'");
    17558   }
    17559   arg2 = reinterpret_cast< char * >(temp2);
    17560   if (arg2) memcpy(arg1->country,arg2,4+2*sizeof(char));
    17561   else memset(arg1->country,0,4+2*sizeof(char));
    17562   resultobj = SWIG_Py_Void();
    17563   return resultobj;
    17564 fail:
    17565   return NULL;
    17566 }
    17567 
    17568 
    17569 SWIGINTERN PyObject *_wrap_PTEID_ADDR_country_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17570   PyObject *resultobj = 0;
    17571   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17572   void *argp1 = 0 ;
    17573   int res1 = 0 ;
    17574   PyObject * obj0 = 0 ;
    17575   char *result = 0 ;
    17576  
    17577   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_country_get",1,1,&obj0)) SWIG_fail;
    17578   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17579   if (!SWIG_IsOK(res1)) {
    17580     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_country_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17581   }
    17582   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17583   result = (char *)(char *) ((arg1)->country);
    17584   {
    17585     size_t size = 4+2;
    17586    
    17587     while (size && (result[size - 1] == '\0')) --size;
    17588    
    17589     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17590   }
    17591   return resultobj;
    17592 fail:
    17593   return NULL;
    17594 }
    17595 
    17596 
    17597 SWIGINTERN PyObject *_wrap_PTEID_ADDR_district_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17598   PyObject *resultobj = 0;
    17599   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17600   char *arg2 ;
    17601   void *argp1 = 0 ;
    17602   int res1 = 0 ;
    17603   char temp2[4+2] ;
    17604   int res2 ;
    17605   PyObject * obj0 = 0 ;
    17606   PyObject * obj1 = 0 ;
    17607  
    17608   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_district_set",2,2,&obj0,&obj1)) SWIG_fail;
    17609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17610   if (!SWIG_IsOK(res1)) {
    17611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_district_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17612   }
    17613   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17614   res2 = SWIG_AsCharArray(obj1, temp2, 4+2);
    17615   if (!SWIG_IsOK(res2)) {
    17616     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_district_set" "', argument " "2"" of type '" "char [4+2]""'");
    17617   }
    17618   arg2 = reinterpret_cast< char * >(temp2);
    17619   if (arg2) memcpy(arg1->district,arg2,4+2*sizeof(char));
    17620   else memset(arg1->district,0,4+2*sizeof(char));
    17621   resultobj = SWIG_Py_Void();
    17622   return resultobj;
    17623 fail:
    17624   return NULL;
    17625 }
    17626 
    17627 
    17628 SWIGINTERN PyObject *_wrap_PTEID_ADDR_district_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17629   PyObject *resultobj = 0;
    17630   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17631   void *argp1 = 0 ;
    17632   int res1 = 0 ;
    17633   PyObject * obj0 = 0 ;
    17634   char *result = 0 ;
    17635  
    17636   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_district_get",1,1,&obj0)) SWIG_fail;
    17637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17638   if (!SWIG_IsOK(res1)) {
    17639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_district_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17640   }
    17641   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17642   result = (char *)(char *) ((arg1)->district);
    17643   {
    17644     size_t size = 4+2;
    17645    
    17646     while (size && (result[size - 1] == '\0')) --size;
    17647    
    17648     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17649   }
    17650   return resultobj;
    17651 fail:
    17652   return NULL;
    17653 }
    17654 
    17655 
    17656 SWIGINTERN PyObject *_wrap_PTEID_ADDR_districtDesc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17657   PyObject *resultobj = 0;
    17658   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17659   char *arg2 ;
    17660   void *argp1 = 0 ;
    17661   int res1 = 0 ;
    17662   char temp2[100+2] ;
    17663   int res2 ;
    17664   PyObject * obj0 = 0 ;
    17665   PyObject * obj1 = 0 ;
    17666  
    17667   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_districtDesc_set",2,2,&obj0,&obj1)) SWIG_fail;
    17668   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17669   if (!SWIG_IsOK(res1)) {
    17670     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_districtDesc_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17671   }
    17672   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17673   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    17674   if (!SWIG_IsOK(res2)) {
    17675     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_districtDesc_set" "', argument " "2"" of type '" "char [100+2]""'");
    17676   }
    17677   arg2 = reinterpret_cast< char * >(temp2);
    17678   if (arg2) memcpy(arg1->districtDesc,arg2,100+2*sizeof(char));
    17679   else memset(arg1->districtDesc,0,100+2*sizeof(char));
    17680   resultobj = SWIG_Py_Void();
    17681   return resultobj;
    17682 fail:
    17683   return NULL;
    17684 }
    17685 
    17686 
    17687 SWIGINTERN PyObject *_wrap_PTEID_ADDR_districtDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17688   PyObject *resultobj = 0;
    17689   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17690   void *argp1 = 0 ;
    17691   int res1 = 0 ;
    17692   PyObject * obj0 = 0 ;
    17693   char *result = 0 ;
    17694  
    17695   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_districtDesc_get",1,1,&obj0)) SWIG_fail;
    17696   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17697   if (!SWIG_IsOK(res1)) {
    17698     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_districtDesc_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17699   }
    17700   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17701   result = (char *)(char *) ((arg1)->districtDesc);
    17702   {
    17703     size_t size = 100+2;
    17704    
    17705     while (size && (result[size - 1] == '\0')) --size;
    17706    
    17707     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17708   }
    17709   return resultobj;
    17710 fail:
    17711   return NULL;
    17712 }
    17713 
    17714 
    17715 SWIGINTERN PyObject *_wrap_PTEID_ADDR_municipality_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17716   PyObject *resultobj = 0;
    17717   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17718   char *arg2 ;
    17719   void *argp1 = 0 ;
    17720   int res1 = 0 ;
    17721   char temp2[8+2] ;
    17722   int res2 ;
    17723   PyObject * obj0 = 0 ;
    17724   PyObject * obj1 = 0 ;
    17725  
    17726   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_municipality_set",2,2,&obj0,&obj1)) SWIG_fail;
    17727   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17728   if (!SWIG_IsOK(res1)) {
    17729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_municipality_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17730   }
    17731   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17732   res2 = SWIG_AsCharArray(obj1, temp2, 8+2);
    17733   if (!SWIG_IsOK(res2)) {
    17734     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_municipality_set" "', argument " "2"" of type '" "char [8+2]""'");
    17735   }
    17736   arg2 = reinterpret_cast< char * >(temp2);
    17737   if (arg2) memcpy(arg1->municipality,arg2,8+2*sizeof(char));
    17738   else memset(arg1->municipality,0,8+2*sizeof(char));
    17739   resultobj = SWIG_Py_Void();
    17740   return resultobj;
    17741 fail:
    17742   return NULL;
    17743 }
    17744 
    17745 
    17746 SWIGINTERN PyObject *_wrap_PTEID_ADDR_municipality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17747   PyObject *resultobj = 0;
    17748   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17749   void *argp1 = 0 ;
    17750   int res1 = 0 ;
    17751   PyObject * obj0 = 0 ;
    17752   char *result = 0 ;
    17753  
    17754   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_municipality_get",1,1,&obj0)) SWIG_fail;
    17755   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17756   if (!SWIG_IsOK(res1)) {
    17757     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_municipality_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17758   }
    17759   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17760   result = (char *)(char *) ((arg1)->municipality);
    17761   {
    17762     size_t size = 8+2;
    17763    
    17764     while (size && (result[size - 1] == '\0')) --size;
    17765    
    17766     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17767   }
    17768   return resultobj;
    17769 fail:
    17770   return NULL;
    17771 }
    17772 
    17773 
    17774 SWIGINTERN PyObject *_wrap_PTEID_ADDR_municipalityDesc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17775   PyObject *resultobj = 0;
    17776   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17777   char *arg2 ;
    17778   void *argp1 = 0 ;
    17779   int res1 = 0 ;
    17780   char temp2[100+2] ;
    17781   int res2 ;
    17782   PyObject * obj0 = 0 ;
    17783   PyObject * obj1 = 0 ;
    17784  
    17785   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_municipalityDesc_set",2,2,&obj0,&obj1)) SWIG_fail;
    17786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17787   if (!SWIG_IsOK(res1)) {
    17788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_municipalityDesc_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17789   }
    17790   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17791   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    17792   if (!SWIG_IsOK(res2)) {
    17793     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_municipalityDesc_set" "', argument " "2"" of type '" "char [100+2]""'");
    17794   }
    17795   arg2 = reinterpret_cast< char * >(temp2);
    17796   if (arg2) memcpy(arg1->municipalityDesc,arg2,100+2*sizeof(char));
    17797   else memset(arg1->municipalityDesc,0,100+2*sizeof(char));
    17798   resultobj = SWIG_Py_Void();
    17799   return resultobj;
    17800 fail:
    17801   return NULL;
    17802 }
    17803 
    17804 
    17805 SWIGINTERN PyObject *_wrap_PTEID_ADDR_municipalityDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17806   PyObject *resultobj = 0;
    17807   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17808   void *argp1 = 0 ;
    17809   int res1 = 0 ;
    17810   PyObject * obj0 = 0 ;
    17811   char *result = 0 ;
    17812  
    17813   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_municipalityDesc_get",1,1,&obj0)) SWIG_fail;
    17814   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17815   if (!SWIG_IsOK(res1)) {
    17816     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_municipalityDesc_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17817   }
    17818   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17819   result = (char *)(char *) ((arg1)->municipalityDesc);
    17820   {
    17821     size_t size = 100+2;
    17822    
    17823     while (size && (result[size - 1] == '\0')) --size;
    17824    
    17825     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17826   }
    17827   return resultobj;
    17828 fail:
    17829   return NULL;
    17830 }
    17831 
    17832 
    17833 SWIGINTERN PyObject *_wrap_PTEID_ADDR_freguesia_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17834   PyObject *resultobj = 0;
    17835   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17836   char *arg2 ;
    17837   void *argp1 = 0 ;
    17838   int res1 = 0 ;
    17839   char temp2[12+2] ;
    17840   int res2 ;
    17841   PyObject * obj0 = 0 ;
    17842   PyObject * obj1 = 0 ;
    17843  
    17844   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_freguesia_set",2,2,&obj0,&obj1)) SWIG_fail;
    17845   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17846   if (!SWIG_IsOK(res1)) {
    17847     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_freguesia_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17848   }
    17849   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17850   res2 = SWIG_AsCharArray(obj1, temp2, 12+2);
    17851   if (!SWIG_IsOK(res2)) {
    17852     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_freguesia_set" "', argument " "2"" of type '" "char [12+2]""'");
    17853   }
    17854   arg2 = reinterpret_cast< char * >(temp2);
    17855   if (arg2) memcpy(arg1->freguesia,arg2,12+2*sizeof(char));
    17856   else memset(arg1->freguesia,0,12+2*sizeof(char));
    17857   resultobj = SWIG_Py_Void();
    17858   return resultobj;
    17859 fail:
    17860   return NULL;
    17861 }
    17862 
    17863 
    17864 SWIGINTERN PyObject *_wrap_PTEID_ADDR_freguesia_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17865   PyObject *resultobj = 0;
    17866   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17867   void *argp1 = 0 ;
    17868   int res1 = 0 ;
    17869   PyObject * obj0 = 0 ;
    17870   char *result = 0 ;
    17871  
    17872   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_freguesia_get",1,1,&obj0)) SWIG_fail;
    17873   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17874   if (!SWIG_IsOK(res1)) {
    17875     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_freguesia_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17876   }
    17877   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17878   result = (char *)(char *) ((arg1)->freguesia);
    17879   {
    17880     size_t size = 12+2;
    17881    
    17882     while (size && (result[size - 1] == '\0')) --size;
    17883    
    17884     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17885   }
    17886   return resultobj;
    17887 fail:
    17888   return NULL;
    17889 }
    17890 
    17891 
    17892 SWIGINTERN PyObject *_wrap_PTEID_ADDR_freguesiaDesc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17893   PyObject *resultobj = 0;
    17894   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17895   char *arg2 ;
    17896   void *argp1 = 0 ;
    17897   int res1 = 0 ;
    17898   char temp2[100+2] ;
    17899   int res2 ;
    17900   PyObject * obj0 = 0 ;
    17901   PyObject * obj1 = 0 ;
    17902  
    17903   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_freguesiaDesc_set",2,2,&obj0,&obj1)) SWIG_fail;
    17904   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17905   if (!SWIG_IsOK(res1)) {
    17906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_freguesiaDesc_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17907   }
    17908   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17909   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    17910   if (!SWIG_IsOK(res2)) {
    17911     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_freguesiaDesc_set" "', argument " "2"" of type '" "char [100+2]""'");
    17912   }
    17913   arg2 = reinterpret_cast< char * >(temp2);
    17914   if (arg2) memcpy(arg1->freguesiaDesc,arg2,100+2*sizeof(char));
    17915   else memset(arg1->freguesiaDesc,0,100+2*sizeof(char));
    17916   resultobj = SWIG_Py_Void();
    17917   return resultobj;
    17918 fail:
    17919   return NULL;
    17920 }
    17921 
    17922 
    17923 SWIGINTERN PyObject *_wrap_PTEID_ADDR_freguesiaDesc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17924   PyObject *resultobj = 0;
    17925   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17926   void *argp1 = 0 ;
    17927   int res1 = 0 ;
    17928   PyObject * obj0 = 0 ;
    17929   char *result = 0 ;
    17930  
    17931   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_freguesiaDesc_get",1,1,&obj0)) SWIG_fail;
    17932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17933   if (!SWIG_IsOK(res1)) {
    17934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_freguesiaDesc_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17935   }
    17936   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17937   result = (char *)(char *) ((arg1)->freguesiaDesc);
    17938   {
    17939     size_t size = 100+2;
    17940    
    17941     while (size && (result[size - 1] == '\0')) --size;
    17942    
    17943     resultobj = SWIG_FromCharPtrAndSize(result, size);
    17944   }
    17945   return resultobj;
    17946 fail:
    17947   return NULL;
    17948 }
    17949 
    17950 
    17951 SWIGINTERN PyObject *_wrap_PTEID_ADDR_streettypeAbbr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17952   PyObject *resultobj = 0;
    17953   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17954   char *arg2 ;
    17955   void *argp1 = 0 ;
    17956   int res1 = 0 ;
    17957   char temp2[20+2] ;
    17958   int res2 ;
    17959   PyObject * obj0 = 0 ;
    17960   PyObject * obj1 = 0 ;
    17961  
    17962   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_streettypeAbbr_set",2,2,&obj0,&obj1)) SWIG_fail;
    17963   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17964   if (!SWIG_IsOK(res1)) {
    17965     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_streettypeAbbr_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17966   }
    17967   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17968   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    17969   if (!SWIG_IsOK(res2)) {
    17970     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_streettypeAbbr_set" "', argument " "2"" of type '" "char [20+2]""'");
    17971   }
    17972   arg2 = reinterpret_cast< char * >(temp2);
    17973   if (arg2) memcpy(arg1->streettypeAbbr,arg2,20+2*sizeof(char));
    17974   else memset(arg1->streettypeAbbr,0,20+2*sizeof(char));
    17975   resultobj = SWIG_Py_Void();
    17976   return resultobj;
    17977 fail:
    17978   return NULL;
    17979 }
    17980 
    17981 
    17982 SWIGINTERN PyObject *_wrap_PTEID_ADDR_streettypeAbbr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    17983   PyObject *resultobj = 0;
    17984   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    17985   void *argp1 = 0 ;
    17986   int res1 = 0 ;
    17987   PyObject * obj0 = 0 ;
    17988   char *result = 0 ;
    17989  
    17990   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_streettypeAbbr_get",1,1,&obj0)) SWIG_fail;
    17991   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    17992   if (!SWIG_IsOK(res1)) {
    17993     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_streettypeAbbr_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    17994   }
    17995   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    17996   result = (char *)(char *) ((arg1)->streettypeAbbr);
    17997   {
    17998     size_t size = 20+2;
    17999    
    18000     while (size && (result[size - 1] == '\0')) --size;
    18001    
    18002     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18003   }
    18004   return resultobj;
    18005 fail:
    18006   return NULL;
    18007 }
    18008 
    18009 
    18010 SWIGINTERN PyObject *_wrap_PTEID_ADDR_streettype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18011   PyObject *resultobj = 0;
    18012   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18013   char *arg2 ;
    18014   void *argp1 = 0 ;
    18015   int res1 = 0 ;
    18016   char temp2[100+2] ;
    18017   int res2 ;
    18018   PyObject * obj0 = 0 ;
    18019   PyObject * obj1 = 0 ;
    18020  
    18021   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_streettype_set",2,2,&obj0,&obj1)) SWIG_fail;
    18022   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18023   if (!SWIG_IsOK(res1)) {
    18024     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_streettype_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18025   }
    18026   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18027   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18028   if (!SWIG_IsOK(res2)) {
    18029     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_streettype_set" "', argument " "2"" of type '" "char [100+2]""'");
    18030   }
    18031   arg2 = reinterpret_cast< char * >(temp2);
    18032   if (arg2) memcpy(arg1->streettype,arg2,100+2*sizeof(char));
    18033   else memset(arg1->streettype,0,100+2*sizeof(char));
    18034   resultobj = SWIG_Py_Void();
    18035   return resultobj;
    18036 fail:
    18037   return NULL;
    18038 }
    18039 
    18040 
    18041 SWIGINTERN PyObject *_wrap_PTEID_ADDR_streettype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18042   PyObject *resultobj = 0;
    18043   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18044   void *argp1 = 0 ;
    18045   int res1 = 0 ;
    18046   PyObject * obj0 = 0 ;
    18047   char *result = 0 ;
    18048  
    18049   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_streettype_get",1,1,&obj0)) SWIG_fail;
    18050   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18051   if (!SWIG_IsOK(res1)) {
    18052     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_streettype_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18053   }
    18054   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18055   result = (char *)(char *) ((arg1)->streettype);
    18056   {
    18057     size_t size = 100+2;
    18058    
    18059     while (size && (result[size - 1] == '\0')) --size;
    18060    
    18061     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18062   }
    18063   return resultobj;
    18064 fail:
    18065   return NULL;
    18066 }
    18067 
    18068 
    18069 SWIGINTERN PyObject *_wrap_PTEID_ADDR_street_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18070   PyObject *resultobj = 0;
    18071   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18072   char *arg2 ;
    18073   void *argp1 = 0 ;
    18074   int res1 = 0 ;
    18075   char temp2[200+2] ;
    18076   int res2 ;
    18077   PyObject * obj0 = 0 ;
    18078   PyObject * obj1 = 0 ;
    18079  
    18080   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_street_set",2,2,&obj0,&obj1)) SWIG_fail;
    18081   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18082   if (!SWIG_IsOK(res1)) {
    18083     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_street_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18084   }
    18085   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18086   res2 = SWIG_AsCharArray(obj1, temp2, 200+2);
    18087   if (!SWIG_IsOK(res2)) {
    18088     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_street_set" "', argument " "2"" of type '" "char [200+2]""'");
    18089   }
    18090   arg2 = reinterpret_cast< char * >(temp2);
    18091   if (arg2) memcpy(arg1->street,arg2,200+2*sizeof(char));
    18092   else memset(arg1->street,0,200+2*sizeof(char));
    18093   resultobj = SWIG_Py_Void();
    18094   return resultobj;
    18095 fail:
    18096   return NULL;
    18097 }
    18098 
    18099 
    18100 SWIGINTERN PyObject *_wrap_PTEID_ADDR_street_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18101   PyObject *resultobj = 0;
    18102   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18103   void *argp1 = 0 ;
    18104   int res1 = 0 ;
    18105   PyObject * obj0 = 0 ;
    18106   char *result = 0 ;
    18107  
    18108   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_street_get",1,1,&obj0)) SWIG_fail;
    18109   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18110   if (!SWIG_IsOK(res1)) {
    18111     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_street_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18112   }
    18113   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18114   result = (char *)(char *) ((arg1)->street);
    18115   {
    18116     size_t size = 200+2;
    18117    
    18118     while (size && (result[size - 1] == '\0')) --size;
    18119    
    18120     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18121   }
    18122   return resultobj;
    18123 fail:
    18124   return NULL;
    18125 }
    18126 
    18127 
    18128 SWIGINTERN PyObject *_wrap_PTEID_ADDR_buildingAbbr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18129   PyObject *resultobj = 0;
    18130   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18131   char *arg2 ;
    18132   void *argp1 = 0 ;
    18133   int res1 = 0 ;
    18134   char temp2[20+2] ;
    18135   int res2 ;
    18136   PyObject * obj0 = 0 ;
    18137   PyObject * obj1 = 0 ;
    18138  
    18139   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_buildingAbbr_set",2,2,&obj0,&obj1)) SWIG_fail;
    18140   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18141   if (!SWIG_IsOK(res1)) {
    18142     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_buildingAbbr_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18143   }
    18144   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18145   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    18146   if (!SWIG_IsOK(res2)) {
    18147     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_buildingAbbr_set" "', argument " "2"" of type '" "char [20+2]""'");
    18148   }
    18149   arg2 = reinterpret_cast< char * >(temp2);
    18150   if (arg2) memcpy(arg1->buildingAbbr,arg2,20+2*sizeof(char));
    18151   else memset(arg1->buildingAbbr,0,20+2*sizeof(char));
    18152   resultobj = SWIG_Py_Void();
    18153   return resultobj;
    18154 fail:
    18155   return NULL;
    18156 }
    18157 
    18158 
    18159 SWIGINTERN PyObject *_wrap_PTEID_ADDR_buildingAbbr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18160   PyObject *resultobj = 0;
    18161   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18162   void *argp1 = 0 ;
    18163   int res1 = 0 ;
    18164   PyObject * obj0 = 0 ;
    18165   char *result = 0 ;
    18166  
    18167   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_buildingAbbr_get",1,1,&obj0)) SWIG_fail;
    18168   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18169   if (!SWIG_IsOK(res1)) {
    18170     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_buildingAbbr_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18171   }
    18172   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18173   result = (char *)(char *) ((arg1)->buildingAbbr);
    18174   {
    18175     size_t size = 20+2;
    18176    
    18177     while (size && (result[size - 1] == '\0')) --size;
    18178    
    18179     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18180   }
    18181   return resultobj;
    18182 fail:
    18183   return NULL;
    18184 }
    18185 
    18186 
    18187 SWIGINTERN PyObject *_wrap_PTEID_ADDR_building_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18188   PyObject *resultobj = 0;
    18189   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18190   char *arg2 ;
    18191   void *argp1 = 0 ;
    18192   int res1 = 0 ;
    18193   char temp2[100+2] ;
    18194   int res2 ;
    18195   PyObject * obj0 = 0 ;
    18196   PyObject * obj1 = 0 ;
    18197  
    18198   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_building_set",2,2,&obj0,&obj1)) SWIG_fail;
    18199   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18200   if (!SWIG_IsOK(res1)) {
    18201     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_building_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18202   }
    18203   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18204   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18205   if (!SWIG_IsOK(res2)) {
    18206     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_building_set" "', argument " "2"" of type '" "char [100+2]""'");
    18207   }
    18208   arg2 = reinterpret_cast< char * >(temp2);
    18209   if (arg2) memcpy(arg1->building,arg2,100+2*sizeof(char));
    18210   else memset(arg1->building,0,100+2*sizeof(char));
    18211   resultobj = SWIG_Py_Void();
    18212   return resultobj;
    18213 fail:
    18214   return NULL;
    18215 }
    18216 
    18217 
    18218 SWIGINTERN PyObject *_wrap_PTEID_ADDR_building_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18219   PyObject *resultobj = 0;
    18220   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18221   void *argp1 = 0 ;
    18222   int res1 = 0 ;
    18223   PyObject * obj0 = 0 ;
    18224   char *result = 0 ;
    18225  
    18226   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_building_get",1,1,&obj0)) SWIG_fail;
    18227   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18228   if (!SWIG_IsOK(res1)) {
    18229     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_building_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18230   }
    18231   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18232   result = (char *)(char *) ((arg1)->building);
    18233   {
    18234     size_t size = 100+2;
    18235    
    18236     while (size && (result[size - 1] == '\0')) --size;
    18237    
    18238     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18239   }
    18240   return resultobj;
    18241 fail:
    18242   return NULL;
    18243 }
    18244 
    18245 
    18246 SWIGINTERN PyObject *_wrap_PTEID_ADDR_door_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18247   PyObject *resultobj = 0;
    18248   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18249   char *arg2 ;
    18250   void *argp1 = 0 ;
    18251   int res1 = 0 ;
    18252   char temp2[20+2] ;
    18253   int res2 ;
    18254   PyObject * obj0 = 0 ;
    18255   PyObject * obj1 = 0 ;
    18256  
    18257   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_door_set",2,2,&obj0,&obj1)) SWIG_fail;
    18258   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18259   if (!SWIG_IsOK(res1)) {
    18260     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_door_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18261   }
    18262   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18263   res2 = SWIG_AsCharArray(obj1, temp2, 20+2);
    18264   if (!SWIG_IsOK(res2)) {
    18265     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_door_set" "', argument " "2"" of type '" "char [20+2]""'");
    18266   }
    18267   arg2 = reinterpret_cast< char * >(temp2);
    18268   if (arg2) memcpy(arg1->door,arg2,20+2*sizeof(char));
    18269   else memset(arg1->door,0,20+2*sizeof(char));
    18270   resultobj = SWIG_Py_Void();
    18271   return resultobj;
    18272 fail:
    18273   return NULL;
    18274 }
    18275 
    18276 
    18277 SWIGINTERN PyObject *_wrap_PTEID_ADDR_door_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18278   PyObject *resultobj = 0;
    18279   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18280   void *argp1 = 0 ;
    18281   int res1 = 0 ;
    18282   PyObject * obj0 = 0 ;
    18283   char *result = 0 ;
    18284  
    18285   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_door_get",1,1,&obj0)) SWIG_fail;
    18286   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18287   if (!SWIG_IsOK(res1)) {
    18288     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_door_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18289   }
    18290   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18291   result = (char *)(char *) ((arg1)->door);
    18292   {
    18293     size_t size = 20+2;
    18294    
    18295     while (size && (result[size - 1] == '\0')) --size;
    18296    
    18297     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18298   }
    18299   return resultobj;
    18300 fail:
    18301   return NULL;
    18302 }
    18303 
    18304 
    18305 SWIGINTERN PyObject *_wrap_PTEID_ADDR_floor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18306   PyObject *resultobj = 0;
    18307   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18308   char *arg2 ;
    18309   void *argp1 = 0 ;
    18310   int res1 = 0 ;
    18311   char temp2[40+2] ;
    18312   int res2 ;
    18313   PyObject * obj0 = 0 ;
    18314   PyObject * obj1 = 0 ;
    18315  
    18316   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_floor_set",2,2,&obj0,&obj1)) SWIG_fail;
    18317   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18318   if (!SWIG_IsOK(res1)) {
    18319     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_floor_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18320   }
    18321   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18322   res2 = SWIG_AsCharArray(obj1, temp2, 40+2);
    18323   if (!SWIG_IsOK(res2)) {
    18324     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_floor_set" "', argument " "2"" of type '" "char [40+2]""'");
    18325   }
    18326   arg2 = reinterpret_cast< char * >(temp2);
    18327   if (arg2) memcpy(arg1->floor,arg2,40+2*sizeof(char));
    18328   else memset(arg1->floor,0,40+2*sizeof(char));
    18329   resultobj = SWIG_Py_Void();
    18330   return resultobj;
    18331 fail:
    18332   return NULL;
    18333 }
    18334 
    18335 
    18336 SWIGINTERN PyObject *_wrap_PTEID_ADDR_floor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18337   PyObject *resultobj = 0;
    18338   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18339   void *argp1 = 0 ;
    18340   int res1 = 0 ;
    18341   PyObject * obj0 = 0 ;
    18342   char *result = 0 ;
    18343  
    18344   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_floor_get",1,1,&obj0)) SWIG_fail;
    18345   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18346   if (!SWIG_IsOK(res1)) {
    18347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_floor_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18348   }
    18349   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18350   result = (char *)(char *) ((arg1)->floor);
    18351   {
    18352     size_t size = 40+2;
    18353    
    18354     while (size && (result[size - 1] == '\0')) --size;
    18355    
    18356     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18357   }
    18358   return resultobj;
    18359 fail:
    18360   return NULL;
    18361 }
    18362 
    18363 
    18364 SWIGINTERN PyObject *_wrap_PTEID_ADDR_side_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18365   PyObject *resultobj = 0;
    18366   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18367   char *arg2 ;
    18368   void *argp1 = 0 ;
    18369   int res1 = 0 ;
    18370   char temp2[40+2] ;
    18371   int res2 ;
    18372   PyObject * obj0 = 0 ;
    18373   PyObject * obj1 = 0 ;
    18374  
    18375   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_side_set",2,2,&obj0,&obj1)) SWIG_fail;
    18376   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18377   if (!SWIG_IsOK(res1)) {
    18378     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_side_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18379   }
    18380   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18381   res2 = SWIG_AsCharArray(obj1, temp2, 40+2);
    18382   if (!SWIG_IsOK(res2)) {
    18383     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_side_set" "', argument " "2"" of type '" "char [40+2]""'");
    18384   }
    18385   arg2 = reinterpret_cast< char * >(temp2);
    18386   if (arg2) memcpy(arg1->side,arg2,40+2*sizeof(char));
    18387   else memset(arg1->side,0,40+2*sizeof(char));
    18388   resultobj = SWIG_Py_Void();
    18389   return resultobj;
    18390 fail:
    18391   return NULL;
    18392 }
    18393 
    18394 
    18395 SWIGINTERN PyObject *_wrap_PTEID_ADDR_side_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18396   PyObject *resultobj = 0;
    18397   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18398   void *argp1 = 0 ;
    18399   int res1 = 0 ;
    18400   PyObject * obj0 = 0 ;
    18401   char *result = 0 ;
    18402  
    18403   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_side_get",1,1,&obj0)) SWIG_fail;
    18404   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18405   if (!SWIG_IsOK(res1)) {
    18406     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_side_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18407   }
    18408   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18409   result = (char *)(char *) ((arg1)->side);
    18410   {
    18411     size_t size = 40+2;
    18412    
    18413     while (size && (result[size - 1] == '\0')) --size;
    18414    
    18415     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18416   }
    18417   return resultobj;
    18418 fail:
    18419   return NULL;
    18420 }
    18421 
    18422 
    18423 SWIGINTERN PyObject *_wrap_PTEID_ADDR_place_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18424   PyObject *resultobj = 0;
    18425   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18426   char *arg2 ;
    18427   void *argp1 = 0 ;
    18428   int res1 = 0 ;
    18429   char temp2[100+2] ;
    18430   int res2 ;
    18431   PyObject * obj0 = 0 ;
    18432   PyObject * obj1 = 0 ;
    18433  
    18434   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_place_set",2,2,&obj0,&obj1)) SWIG_fail;
    18435   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18436   if (!SWIG_IsOK(res1)) {
    18437     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_place_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18438   }
    18439   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18440   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18441   if (!SWIG_IsOK(res2)) {
    18442     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_place_set" "', argument " "2"" of type '" "char [100+2]""'");
    18443   }
    18444   arg2 = reinterpret_cast< char * >(temp2);
    18445   if (arg2) memcpy(arg1->place,arg2,100+2*sizeof(char));
    18446   else memset(arg1->place,0,100+2*sizeof(char));
    18447   resultobj = SWIG_Py_Void();
    18448   return resultobj;
    18449 fail:
    18450   return NULL;
    18451 }
    18452 
    18453 
    18454 SWIGINTERN PyObject *_wrap_PTEID_ADDR_place_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18455   PyObject *resultobj = 0;
    18456   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18457   void *argp1 = 0 ;
    18458   int res1 = 0 ;
    18459   PyObject * obj0 = 0 ;
    18460   char *result = 0 ;
    18461  
    18462   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_place_get",1,1,&obj0)) SWIG_fail;
    18463   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18464   if (!SWIG_IsOK(res1)) {
    18465     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_place_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18466   }
    18467   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18468   result = (char *)(char *) ((arg1)->place);
    18469   {
    18470     size_t size = 100+2;
    18471    
    18472     while (size && (result[size - 1] == '\0')) --size;
    18473    
    18474     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18475   }
    18476   return resultobj;
    18477 fail:
    18478   return NULL;
    18479 }
    18480 
    18481 
    18482 SWIGINTERN PyObject *_wrap_PTEID_ADDR_locality_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18483   PyObject *resultobj = 0;
    18484   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18485   char *arg2 ;
    18486   void *argp1 = 0 ;
    18487   int res1 = 0 ;
    18488   char temp2[100+2] ;
    18489   int res2 ;
    18490   PyObject * obj0 = 0 ;
    18491   PyObject * obj1 = 0 ;
    18492  
    18493   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_locality_set",2,2,&obj0,&obj1)) SWIG_fail;
    18494   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18495   if (!SWIG_IsOK(res1)) {
    18496     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_locality_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18497   }
    18498   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18499   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18500   if (!SWIG_IsOK(res2)) {
    18501     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_locality_set" "', argument " "2"" of type '" "char [100+2]""'");
    18502   }
    18503   arg2 = reinterpret_cast< char * >(temp2);
    18504   if (arg2) memcpy(arg1->locality,arg2,100+2*sizeof(char));
    18505   else memset(arg1->locality,0,100+2*sizeof(char));
    18506   resultobj = SWIG_Py_Void();
    18507   return resultobj;
    18508 fail:
    18509   return NULL;
    18510 }
    18511 
    18512 
    18513 SWIGINTERN PyObject *_wrap_PTEID_ADDR_locality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18514   PyObject *resultobj = 0;
    18515   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18516   void *argp1 = 0 ;
    18517   int res1 = 0 ;
    18518   PyObject * obj0 = 0 ;
    18519   char *result = 0 ;
    18520  
    18521   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_locality_get",1,1,&obj0)) SWIG_fail;
    18522   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18523   if (!SWIG_IsOK(res1)) {
    18524     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_locality_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18525   }
    18526   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18527   result = (char *)(char *) ((arg1)->locality);
    18528   {
    18529     size_t size = 100+2;
    18530    
    18531     while (size && (result[size - 1] == '\0')) --size;
    18532    
    18533     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18534   }
    18535   return resultobj;
    18536 fail:
    18537   return NULL;
    18538 }
    18539 
    18540 
    18541 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cp4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18542   PyObject *resultobj = 0;
    18543   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18544   char *arg2 ;
    18545   void *argp1 = 0 ;
    18546   int res1 = 0 ;
    18547   char temp2[8+2] ;
    18548   int res2 ;
    18549   PyObject * obj0 = 0 ;
    18550   PyObject * obj1 = 0 ;
    18551  
    18552   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cp4_set",2,2,&obj0,&obj1)) SWIG_fail;
    18553   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18554   if (!SWIG_IsOK(res1)) {
    18555     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cp4_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18556   }
    18557   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18558   res2 = SWIG_AsCharArray(obj1, temp2, 8+2);
    18559   if (!SWIG_IsOK(res2)) {
    18560     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_cp4_set" "', argument " "2"" of type '" "char [8+2]""'");
    18561   }
    18562   arg2 = reinterpret_cast< char * >(temp2);
    18563   if (arg2) memcpy(arg1->cp4,arg2,8+2*sizeof(char));
    18564   else memset(arg1->cp4,0,8+2*sizeof(char));
    18565   resultobj = SWIG_Py_Void();
    18566   return resultobj;
    18567 fail:
    18568   return NULL;
    18569 }
    18570 
    18571 
    18572 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cp4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18573   PyObject *resultobj = 0;
    18574   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18575   void *argp1 = 0 ;
    18576   int res1 = 0 ;
    18577   PyObject * obj0 = 0 ;
    18578   char *result = 0 ;
    18579  
    18580   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cp4_get",1,1,&obj0)) SWIG_fail;
    18581   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18582   if (!SWIG_IsOK(res1)) {
    18583     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cp4_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18584   }
    18585   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18586   result = (char *)(char *) ((arg1)->cp4);
    18587   {
    18588     size_t size = 8+2;
    18589    
    18590     while (size && (result[size - 1] == '\0')) --size;
    18591    
    18592     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18593   }
    18594   return resultobj;
    18595 fail:
    18596   return NULL;
    18597 }
    18598 
    18599 
    18600 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cp3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18601   PyObject *resultobj = 0;
    18602   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18603   char *arg2 ;
    18604   void *argp1 = 0 ;
    18605   int res1 = 0 ;
    18606   char temp2[6+2] ;
    18607   int res2 ;
    18608   PyObject * obj0 = 0 ;
    18609   PyObject * obj1 = 0 ;
    18610  
    18611   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cp3_set",2,2,&obj0,&obj1)) SWIG_fail;
    18612   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18613   if (!SWIG_IsOK(res1)) {
    18614     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cp3_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18615   }
    18616   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18617   res2 = SWIG_AsCharArray(obj1, temp2, 6+2);
    18618   if (!SWIG_IsOK(res2)) {
    18619     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_cp3_set" "', argument " "2"" of type '" "char [6+2]""'");
    18620   }
    18621   arg2 = reinterpret_cast< char * >(temp2);
    18622   if (arg2) memcpy(arg1->cp3,arg2,6+2*sizeof(char));
    18623   else memset(arg1->cp3,0,6+2*sizeof(char));
    18624   resultobj = SWIG_Py_Void();
    18625   return resultobj;
    18626 fail:
    18627   return NULL;
    18628 }
    18629 
    18630 
    18631 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cp3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18632   PyObject *resultobj = 0;
    18633   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18634   void *argp1 = 0 ;
    18635   int res1 = 0 ;
    18636   PyObject * obj0 = 0 ;
    18637   char *result = 0 ;
    18638  
    18639   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cp3_get",1,1,&obj0)) SWIG_fail;
    18640   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18641   if (!SWIG_IsOK(res1)) {
    18642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cp3_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18643   }
    18644   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18645   result = (char *)(char *) ((arg1)->cp3);
    18646   {
    18647     size_t size = 6+2;
    18648    
    18649     while (size && (result[size - 1] == '\0')) --size;
    18650    
    18651     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18652   }
    18653   return resultobj;
    18654 fail:
    18655   return NULL;
    18656 }
    18657 
    18658 
    18659 SWIGINTERN PyObject *_wrap_PTEID_ADDR_postal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18660   PyObject *resultobj = 0;
    18661   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18662   char *arg2 ;
    18663   void *argp1 = 0 ;
    18664   int res1 = 0 ;
    18665   char temp2[50+2] ;
    18666   int res2 ;
    18667   PyObject * obj0 = 0 ;
    18668   PyObject * obj1 = 0 ;
    18669  
    18670   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_postal_set",2,2,&obj0,&obj1)) SWIG_fail;
    18671   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18672   if (!SWIG_IsOK(res1)) {
    18673     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_postal_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18674   }
    18675   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18676   res2 = SWIG_AsCharArray(obj1, temp2, 50+2);
    18677   if (!SWIG_IsOK(res2)) {
    18678     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_postal_set" "', argument " "2"" of type '" "char [50+2]""'");
    18679   }
    18680   arg2 = reinterpret_cast< char * >(temp2);
    18681   if (arg2) memcpy(arg1->postal,arg2,50+2*sizeof(char));
    18682   else memset(arg1->postal,0,50+2*sizeof(char));
    18683   resultobj = SWIG_Py_Void();
    18684   return resultobj;
    18685 fail:
    18686   return NULL;
    18687 }
    18688 
    18689 
    18690 SWIGINTERN PyObject *_wrap_PTEID_ADDR_postal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18691   PyObject *resultobj = 0;
    18692   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18693   void *argp1 = 0 ;
    18694   int res1 = 0 ;
    18695   PyObject * obj0 = 0 ;
    18696   char *result = 0 ;
    18697  
    18698   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_postal_get",1,1,&obj0)) SWIG_fail;
    18699   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18700   if (!SWIG_IsOK(res1)) {
    18701     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_postal_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18702   }
    18703   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18704   result = (char *)(char *) ((arg1)->postal);
    18705   {
    18706     size_t size = 50+2;
    18707    
    18708     while (size && (result[size - 1] == '\0')) --size;
    18709    
    18710     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18711   }
    18712   return resultobj;
    18713 fail:
    18714   return NULL;
    18715 }
    18716 
    18717 
    18718 SWIGINTERN PyObject *_wrap_PTEID_ADDR_numMor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18719   PyObject *resultobj = 0;
    18720   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18721   char *arg2 ;
    18722   void *argp1 = 0 ;
    18723   int res1 = 0 ;
    18724   char temp2[12+2] ;
    18725   int res2 ;
    18726   PyObject * obj0 = 0 ;
    18727   PyObject * obj1 = 0 ;
    18728  
    18729   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_numMor_set",2,2,&obj0,&obj1)) SWIG_fail;
    18730   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18731   if (!SWIG_IsOK(res1)) {
    18732     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_numMor_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18733   }
    18734   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18735   res2 = SWIG_AsCharArray(obj1, temp2, 12+2);
    18736   if (!SWIG_IsOK(res2)) {
    18737     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_numMor_set" "', argument " "2"" of type '" "char [12+2]""'");
    18738   }
    18739   arg2 = reinterpret_cast< char * >(temp2);
    18740   if (arg2) memcpy(arg1->numMor,arg2,12+2*sizeof(char));
    18741   else memset(arg1->numMor,0,12+2*sizeof(char));
    18742   resultobj = SWIG_Py_Void();
    18743   return resultobj;
    18744 fail:
    18745   return NULL;
    18746 }
    18747 
    18748 
    18749 SWIGINTERN PyObject *_wrap_PTEID_ADDR_numMor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18750   PyObject *resultobj = 0;
    18751   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18752   void *argp1 = 0 ;
    18753   int res1 = 0 ;
    18754   PyObject * obj0 = 0 ;
    18755   char *result = 0 ;
    18756  
    18757   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_numMor_get",1,1,&obj0)) SWIG_fail;
    18758   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18759   if (!SWIG_IsOK(res1)) {
    18760     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_numMor_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18761   }
    18762   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18763   result = (char *)(char *) ((arg1)->numMor);
    18764   {
    18765     size_t size = 12+2;
    18766    
    18767     while (size && (result[size - 1] == '\0')) --size;
    18768    
    18769     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18770   }
    18771   return resultobj;
    18772 fail:
    18773   return NULL;
    18774 }
    18775 
    18776 
    18777 SWIGINTERN PyObject *_wrap_PTEID_ADDR_countryDescF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18778   PyObject *resultobj = 0;
    18779   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18780   char *arg2 ;
    18781   void *argp1 = 0 ;
    18782   int res1 = 0 ;
    18783   char temp2[100+2] ;
    18784   int res2 ;
    18785   PyObject * obj0 = 0 ;
    18786   PyObject * obj1 = 0 ;
    18787  
    18788   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_countryDescF_set",2,2,&obj0,&obj1)) SWIG_fail;
    18789   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18790   if (!SWIG_IsOK(res1)) {
    18791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_countryDescF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18792   }
    18793   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18794   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18795   if (!SWIG_IsOK(res2)) {
    18796     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_countryDescF_set" "', argument " "2"" of type '" "char [100+2]""'");
    18797   }
    18798   arg2 = reinterpret_cast< char * >(temp2);
    18799   if (arg2) memcpy(arg1->countryDescF,arg2,100+2*sizeof(char));
    18800   else memset(arg1->countryDescF,0,100+2*sizeof(char));
    18801   resultobj = SWIG_Py_Void();
    18802   return resultobj;
    18803 fail:
    18804   return NULL;
    18805 }
    18806 
    18807 
    18808 SWIGINTERN PyObject *_wrap_PTEID_ADDR_countryDescF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18809   PyObject *resultobj = 0;
    18810   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18811   void *argp1 = 0 ;
    18812   int res1 = 0 ;
    18813   PyObject * obj0 = 0 ;
    18814   char *result = 0 ;
    18815  
    18816   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_countryDescF_get",1,1,&obj0)) SWIG_fail;
    18817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18818   if (!SWIG_IsOK(res1)) {
    18819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_countryDescF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18820   }
    18821   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18822   result = (char *)(char *) ((arg1)->countryDescF);
    18823   {
    18824     size_t size = 100+2;
    18825    
    18826     while (size && (result[size - 1] == '\0')) --size;
    18827    
    18828     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18829   }
    18830   return resultobj;
    18831 fail:
    18832   return NULL;
    18833 }
    18834 
    18835 
    18836 SWIGINTERN PyObject *_wrap_PTEID_ADDR_addressF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18837   PyObject *resultobj = 0;
    18838   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18839   char *arg2 ;
    18840   void *argp1 = 0 ;
    18841   int res1 = 0 ;
    18842   char temp2[300+2] ;
    18843   int res2 ;
    18844   PyObject * obj0 = 0 ;
    18845   PyObject * obj1 = 0 ;
    18846  
    18847   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_addressF_set",2,2,&obj0,&obj1)) SWIG_fail;
    18848   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18849   if (!SWIG_IsOK(res1)) {
    18850     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_addressF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18851   }
    18852   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18853   res2 = SWIG_AsCharArray(obj1, temp2, 300+2);
    18854   if (!SWIG_IsOK(res2)) {
    18855     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_addressF_set" "', argument " "2"" of type '" "char [300+2]""'");
    18856   }
    18857   arg2 = reinterpret_cast< char * >(temp2);
    18858   if (arg2) memcpy(arg1->addressF,arg2,300+2*sizeof(char));
    18859   else memset(arg1->addressF,0,300+2*sizeof(char));
    18860   resultobj = SWIG_Py_Void();
    18861   return resultobj;
    18862 fail:
    18863   return NULL;
    18864 }
    18865 
    18866 
    18867 SWIGINTERN PyObject *_wrap_PTEID_ADDR_addressF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18868   PyObject *resultobj = 0;
    18869   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18870   void *argp1 = 0 ;
    18871   int res1 = 0 ;
    18872   PyObject * obj0 = 0 ;
    18873   char *result = 0 ;
    18874  
    18875   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_addressF_get",1,1,&obj0)) SWIG_fail;
    18876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18877   if (!SWIG_IsOK(res1)) {
    18878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_addressF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18879   }
    18880   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18881   result = (char *)(char *) ((arg1)->addressF);
    18882   {
    18883     size_t size = 300+2;
    18884    
    18885     while (size && (result[size - 1] == '\0')) --size;
    18886    
    18887     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18888   }
    18889   return resultobj;
    18890 fail:
    18891   return NULL;
    18892 }
    18893 
    18894 
    18895 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cityF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18896   PyObject *resultobj = 0;
    18897   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18898   char *arg2 ;
    18899   void *argp1 = 0 ;
    18900   int res1 = 0 ;
    18901   char temp2[100+2] ;
    18902   int res2 ;
    18903   PyObject * obj0 = 0 ;
    18904   PyObject * obj1 = 0 ;
    18905  
    18906   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cityF_set",2,2,&obj0,&obj1)) SWIG_fail;
    18907   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18908   if (!SWIG_IsOK(res1)) {
    18909     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cityF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18910   }
    18911   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18912   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18913   if (!SWIG_IsOK(res2)) {
    18914     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_cityF_set" "', argument " "2"" of type '" "char [100+2]""'");
    18915   }
    18916   arg2 = reinterpret_cast< char * >(temp2);
    18917   if (arg2) memcpy(arg1->cityF,arg2,100+2*sizeof(char));
    18918   else memset(arg1->cityF,0,100+2*sizeof(char));
    18919   resultobj = SWIG_Py_Void();
    18920   return resultobj;
    18921 fail:
    18922   return NULL;
    18923 }
    18924 
    18925 
    18926 SWIGINTERN PyObject *_wrap_PTEID_ADDR_cityF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18927   PyObject *resultobj = 0;
    18928   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18929   void *argp1 = 0 ;
    18930   int res1 = 0 ;
    18931   PyObject * obj0 = 0 ;
    18932   char *result = 0 ;
    18933  
    18934   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_cityF_get",1,1,&obj0)) SWIG_fail;
    18935   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18936   if (!SWIG_IsOK(res1)) {
    18937     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_cityF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18938   }
    18939   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18940   result = (char *)(char *) ((arg1)->cityF);
    18941   {
    18942     size_t size = 100+2;
    18943    
    18944     while (size && (result[size - 1] == '\0')) --size;
    18945    
    18946     resultobj = SWIG_FromCharPtrAndSize(result, size);
    18947   }
    18948   return resultobj;
    18949 fail:
    18950   return NULL;
    18951 }
    18952 
    18953 
    18954 SWIGINTERN PyObject *_wrap_PTEID_ADDR_regioF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18955   PyObject *resultobj = 0;
    18956   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18957   char *arg2 ;
    18958   void *argp1 = 0 ;
    18959   int res1 = 0 ;
    18960   char temp2[100+2] ;
    18961   int res2 ;
    18962   PyObject * obj0 = 0 ;
    18963   PyObject * obj1 = 0 ;
    18964  
    18965   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_regioF_set",2,2,&obj0,&obj1)) SWIG_fail;
    18966   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18967   if (!SWIG_IsOK(res1)) {
    18968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_regioF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18969   }
    18970   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18971   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    18972   if (!SWIG_IsOK(res2)) {
    18973     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_regioF_set" "', argument " "2"" of type '" "char [100+2]""'");
    18974   }
    18975   arg2 = reinterpret_cast< char * >(temp2);
    18976   if (arg2) memcpy(arg1->regioF,arg2,100+2*sizeof(char));
    18977   else memset(arg1->regioF,0,100+2*sizeof(char));
    18978   resultobj = SWIG_Py_Void();
    18979   return resultobj;
    18980 fail:
    18981   return NULL;
    18982 }
    18983 
    18984 
    18985 SWIGINTERN PyObject *_wrap_PTEID_ADDR_regioF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    18986   PyObject *resultobj = 0;
    18987   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    18988   void *argp1 = 0 ;
    18989   int res1 = 0 ;
    18990   PyObject * obj0 = 0 ;
    18991   char *result = 0 ;
    18992  
    18993   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_regioF_get",1,1,&obj0)) SWIG_fail;
    18994   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    18995   if (!SWIG_IsOK(res1)) {
    18996     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_regioF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    18997   }
    18998   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    18999   result = (char *)(char *) ((arg1)->regioF);
    19000   {
    19001     size_t size = 100+2;
    19002    
    19003     while (size && (result[size - 1] == '\0')) --size;
    19004    
    19005     resultobj = SWIG_FromCharPtrAndSize(result, size);
    19006   }
    19007   return resultobj;
    19008 fail:
    19009   return NULL;
    19010 }
    19011 
    19012 
    19013 SWIGINTERN PyObject *_wrap_PTEID_ADDR_localityF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19014   PyObject *resultobj = 0;
    19015   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19016   char *arg2 ;
    19017   void *argp1 = 0 ;
    19018   int res1 = 0 ;
    19019   char temp2[100+2] ;
    19020   int res2 ;
    19021   PyObject * obj0 = 0 ;
    19022   PyObject * obj1 = 0 ;
    19023  
    19024   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_localityF_set",2,2,&obj0,&obj1)) SWIG_fail;
    19025   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19026   if (!SWIG_IsOK(res1)) {
    19027     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_localityF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19028   }
    19029   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19030   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    19031   if (!SWIG_IsOK(res2)) {
    19032     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_localityF_set" "', argument " "2"" of type '" "char [100+2]""'");
    19033   }
    19034   arg2 = reinterpret_cast< char * >(temp2);
    19035   if (arg2) memcpy(arg1->localityF,arg2,100+2*sizeof(char));
    19036   else memset(arg1->localityF,0,100+2*sizeof(char));
    19037   resultobj = SWIG_Py_Void();
    19038   return resultobj;
    19039 fail:
    19040   return NULL;
    19041 }
    19042 
    19043 
    19044 SWIGINTERN PyObject *_wrap_PTEID_ADDR_localityF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19045   PyObject *resultobj = 0;
    19046   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19047   void *argp1 = 0 ;
    19048   int res1 = 0 ;
    19049   PyObject * obj0 = 0 ;
    19050   char *result = 0 ;
    19051  
    19052   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_localityF_get",1,1,&obj0)) SWIG_fail;
    19053   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19054   if (!SWIG_IsOK(res1)) {
    19055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_localityF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19056   }
    19057   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19058   result = (char *)(char *) ((arg1)->localityF);
    19059   {
    19060     size_t size = 100+2;
    19061    
    19062     while (size && (result[size - 1] == '\0')) --size;
    19063    
    19064     resultobj = SWIG_FromCharPtrAndSize(result, size);
    19065   }
    19066   return resultobj;
    19067 fail:
    19068   return NULL;
    19069 }
    19070 
    19071 
    19072 SWIGINTERN PyObject *_wrap_PTEID_ADDR_postalF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19073   PyObject *resultobj = 0;
    19074   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19075   char *arg2 ;
    19076   void *argp1 = 0 ;
    19077   int res1 = 0 ;
    19078   char temp2[100+2] ;
    19079   int res2 ;
    19080   PyObject * obj0 = 0 ;
    19081   PyObject * obj1 = 0 ;
    19082  
    19083   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_postalF_set",2,2,&obj0,&obj1)) SWIG_fail;
    19084   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19085   if (!SWIG_IsOK(res1)) {
    19086     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_postalF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19087   }
    19088   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19089   res2 = SWIG_AsCharArray(obj1, temp2, 100+2);
    19090   if (!SWIG_IsOK(res2)) {
    19091     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_postalF_set" "', argument " "2"" of type '" "char [100+2]""'");
    19092   }
    19093   arg2 = reinterpret_cast< char * >(temp2);
    19094   if (arg2) memcpy(arg1->postalF,arg2,100+2*sizeof(char));
    19095   else memset(arg1->postalF,0,100+2*sizeof(char));
    19096   resultobj = SWIG_Py_Void();
    19097   return resultobj;
    19098 fail:
    19099   return NULL;
    19100 }
    19101 
    19102 
    19103 SWIGINTERN PyObject *_wrap_PTEID_ADDR_postalF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19104   PyObject *resultobj = 0;
    19105   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19106   void *argp1 = 0 ;
    19107   int res1 = 0 ;
    19108   PyObject * obj0 = 0 ;
    19109   char *result = 0 ;
    19110  
    19111   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_postalF_get",1,1,&obj0)) SWIG_fail;
    19112   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19113   if (!SWIG_IsOK(res1)) {
    19114     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_postalF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19115   }
    19116   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19117   result = (char *)(char *) ((arg1)->postalF);
    19118   {
    19119     size_t size = 100+2;
    19120    
    19121     while (size && (result[size - 1] == '\0')) --size;
    19122    
    19123     resultobj = SWIG_FromCharPtrAndSize(result, size);
    19124   }
    19125   return resultobj;
    19126 fail:
    19127   return NULL;
    19128 }
    19129 
    19130 
    19131 SWIGINTERN PyObject *_wrap_PTEID_ADDR_numMorF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19132   PyObject *resultobj = 0;
    19133   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19134   char *arg2 ;
    19135   void *argp1 = 0 ;
    19136   int res1 = 0 ;
    19137   char temp2[12+2] ;
    19138   int res2 ;
    19139   PyObject * obj0 = 0 ;
    19140   PyObject * obj1 = 0 ;
    19141  
    19142   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_numMorF_set",2,2,&obj0,&obj1)) SWIG_fail;
    19143   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19144   if (!SWIG_IsOK(res1)) {
    19145     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_numMorF_set" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19146   }
    19147   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19148   res2 = SWIG_AsCharArray(obj1, temp2, 12+2);
    19149   if (!SWIG_IsOK(res2)) {
    19150     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ADDR_numMorF_set" "', argument " "2"" of type '" "char [12+2]""'");
    19151   }
    19152   arg2 = reinterpret_cast< char * >(temp2);
    19153   if (arg2) memcpy(arg1->numMorF,arg2,12+2*sizeof(char));
    19154   else memset(arg1->numMorF,0,12+2*sizeof(char));
    19155   resultobj = SWIG_Py_Void();
    19156   return resultobj;
    19157 fail:
    19158   return NULL;
    19159 }
    19160 
    19161 
    19162 SWIGINTERN PyObject *_wrap_PTEID_ADDR_numMorF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19163   PyObject *resultobj = 0;
    19164   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19165   void *argp1 = 0 ;
    19166   int res1 = 0 ;
    19167   PyObject * obj0 = 0 ;
    19168   char *result = 0 ;
    19169  
    19170   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ADDR_numMorF_get",1,1,&obj0)) SWIG_fail;
    19171   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    19172   if (!SWIG_IsOK(res1)) {
    19173     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ADDR_numMorF_get" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19174   }
    19175   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19176   result = (char *)(char *) ((arg1)->numMorF);
    19177   {
    19178     size_t size = 12+2;
    19179    
    19180     while (size && (result[size - 1] == '\0')) --size;
    19181    
    19182     resultobj = SWIG_FromCharPtrAndSize(result, size);
    19183   }
    19184   return resultobj;
    19185 fail:
    19186   return NULL;
    19187 }
    19188 
    19189 
    19190 SWIGINTERN PyObject *_wrap_new_PTEID_ADDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19191   PyObject *resultobj = 0;
    19192   eIDMW::PTEID_ADDR *result = 0 ;
    19193  
    19194   result = (eIDMW::PTEID_ADDR *)new eIDMW::PTEID_ADDR();
    19195   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_ADDR, SWIG_POINTER_NEW |  0 );
    19196   return resultobj;
    19197 fail:
    19198   return NULL;
    19199 }
    19200 
    19201 
    19202 SWIGINTERN PyObject *_wrap_delete_PTEID_ADDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19203   PyObject *resultobj = 0;
    19204   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    19205   void *argp1 = 0 ;
    19206   int res1 = 0 ;
    19207   PyObject * obj0 = 0 ;
    19208  
    19209   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_ADDR",1,1,&obj0)) SWIG_fail;
    19210   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, SWIG_POINTER_DISOWN |  0 );
    19211   if (!SWIG_IsOK(res1)) {
    19212     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_ADDR" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    19213   }
    19214   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    19215   delete arg1;
    19216   resultobj = SWIG_Py_Void();
    19217   return resultobj;
    19218 fail:
    19219   return NULL;
    19220 }
    19221 
    19222 
    19223 SWIGINTERN PyObject *PTEID_ADDR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19224   PyObject *obj;
    19225   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    19226   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_ADDR, SWIG_NewClientData(obj));
    19227   return SWIG_Py_Void();
    19228 }
    19229 
    19230 SWIGINTERN PyObject *_wrap_PTEID_PIC_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19231   PyObject *resultobj = 0;
    19232   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19233   short arg2 ;
    19234   void *argp1 = 0 ;
    19235   int res1 = 0 ;
    19236   short val2 ;
    19237   int ecode2 = 0 ;
    19238   PyObject * obj0 = 0 ;
    19239   PyObject * obj1 = 0 ;
    19240  
    19241   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_version_set",2,2,&obj0,&obj1)) SWIG_fail;
    19242   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19243   if (!SWIG_IsOK(res1)) {
    19244     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_version_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19245   }
    19246   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19247   ecode2 = SWIG_AsVal_short(obj1, &val2);
    19248   if (!SWIG_IsOK(ecode2)) {
    19249     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_PIC_version_set" "', argument " "2"" of type '" "short""'");
    19250   }
    19251   arg2 = static_cast< short >(val2);
    19252   if (arg1) (arg1)->version = arg2;
    19253   resultobj = SWIG_Py_Void();
    19254   return resultobj;
    19255 fail:
    19256   return NULL;
    19257 }
    19258 
    19259 
    19260 SWIGINTERN PyObject *_wrap_PTEID_PIC_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19261   PyObject *resultobj = 0;
    19262   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19263   void *argp1 = 0 ;
    19264   int res1 = 0 ;
    19265   PyObject * obj0 = 0 ;
    19266   short result;
    19267  
    19268   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_version_get",1,1,&obj0)) SWIG_fail;
    19269   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19270   if (!SWIG_IsOK(res1)) {
    19271     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_version_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19272   }
    19273   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19274   result = (short) ((arg1)->version);
    19275   resultobj = SWIG_From_short(static_cast< short >(result));
    19276   return resultobj;
    19277 fail:
    19278   return NULL;
    19279 }
    19280 
    19281 
    19282 SWIGINTERN PyObject *_wrap_PTEID_PIC_cbeff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19283   PyObject *resultobj = 0;
    19284   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19285   unsigned char *arg2 ;
    19286   void *argp1 = 0 ;
    19287   int res1 = 0 ;
    19288   void *argp2 = 0 ;
    19289   int res2 = 0 ;
    19290   PyObject * obj0 = 0 ;
    19291   PyObject * obj1 = 0 ;
    19292  
    19293   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_cbeff_set",2,2,&obj0,&obj1)) SWIG_fail;
    19294   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19295   if (!SWIG_IsOK(res1)) {
    19296     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_cbeff_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19297   }
    19298   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19299   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19300   if (!SWIG_IsOK(res2)) {
    19301     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_PIC_cbeff_set" "', argument " "2"" of type '" "unsigned char [34]""'");
    19302   }
    19303   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19304   {
    19305     if (arg2) {
    19306       size_t ii = 0;
    19307       for (; ii < (size_t)34; ++ii) arg1->cbeff[ii] = arg2[ii];
    19308     } else {
    19309       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""cbeff""' of type '""unsigned char [34]""'");
    19310     }
    19311   }
    19312   resultobj = SWIG_Py_Void();
    19313   return resultobj;
    19314 fail:
    19315   return NULL;
    19316 }
    19317 
    19318 
    19319 SWIGINTERN PyObject *_wrap_PTEID_PIC_cbeff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19320   PyObject *resultobj = 0;
    19321   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19322   void *argp1 = 0 ;
    19323   int res1 = 0 ;
    19324   PyObject * obj0 = 0 ;
    19325   unsigned char *result = 0 ;
    19326  
    19327   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_cbeff_get",1,1,&obj0)) SWIG_fail;
    19328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19329   if (!SWIG_IsOK(res1)) {
    19330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_cbeff_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19331   }
    19332   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19333   result = (unsigned char *)(unsigned char *) ((arg1)->cbeff);
    19334   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19335   return resultobj;
    19336 fail:
    19337   return NULL;
    19338 }
    19339 
    19340 
    19341 SWIGINTERN PyObject *_wrap_PTEID_PIC_facialrechdr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19342   PyObject *resultobj = 0;
    19343   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19344   unsigned char *arg2 ;
    19345   void *argp1 = 0 ;
    19346   int res1 = 0 ;
    19347   void *argp2 = 0 ;
    19348   int res2 = 0 ;
    19349   PyObject * obj0 = 0 ;
    19350   PyObject * obj1 = 0 ;
    19351  
    19352   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_facialrechdr_set",2,2,&obj0,&obj1)) SWIG_fail;
    19353   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19354   if (!SWIG_IsOK(res1)) {
    19355     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_facialrechdr_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19356   }
    19357   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19358   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19359   if (!SWIG_IsOK(res2)) {
    19360     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_PIC_facialrechdr_set" "', argument " "2"" of type '" "unsigned char [14]""'");
    19361   }
    19362   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19363   {
    19364     if (arg2) {
    19365       size_t ii = 0;
    19366       for (; ii < (size_t)14; ++ii) arg1->facialrechdr[ii] = arg2[ii];
    19367     } else {
    19368       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""facialrechdr""' of type '""unsigned char [14]""'");
    19369     }
    19370   }
    19371   resultobj = SWIG_Py_Void();
    19372   return resultobj;
    19373 fail:
    19374   return NULL;
    19375 }
    19376 
    19377 
    19378 SWIGINTERN PyObject *_wrap_PTEID_PIC_facialrechdr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19379   PyObject *resultobj = 0;
    19380   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19381   void *argp1 = 0 ;
    19382   int res1 = 0 ;
    19383   PyObject * obj0 = 0 ;
    19384   unsigned char *result = 0 ;
    19385  
    19386   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_facialrechdr_get",1,1,&obj0)) SWIG_fail;
    19387   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19388   if (!SWIG_IsOK(res1)) {
    19389     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_facialrechdr_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19390   }
    19391   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19392   result = (unsigned char *)(unsigned char *) ((arg1)->facialrechdr);
    19393   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19394   return resultobj;
    19395 fail:
    19396   return NULL;
    19397 }
    19398 
    19399 
    19400 SWIGINTERN PyObject *_wrap_PTEID_PIC_facialinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19401   PyObject *resultobj = 0;
    19402   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19403   unsigned char *arg2 ;
    19404   void *argp1 = 0 ;
    19405   int res1 = 0 ;
    19406   void *argp2 = 0 ;
    19407   int res2 = 0 ;
    19408   PyObject * obj0 = 0 ;
    19409   PyObject * obj1 = 0 ;
    19410  
    19411   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_facialinfo_set",2,2,&obj0,&obj1)) SWIG_fail;
    19412   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19413   if (!SWIG_IsOK(res1)) {
    19414     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_facialinfo_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19415   }
    19416   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19417   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19418   if (!SWIG_IsOK(res2)) {
    19419     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_PIC_facialinfo_set" "', argument " "2"" of type '" "unsigned char [20]""'");
    19420   }
    19421   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19422   {
    19423     if (arg2) {
    19424       size_t ii = 0;
    19425       for (; ii < (size_t)20; ++ii) arg1->facialinfo[ii] = arg2[ii];
    19426     } else {
    19427       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""facialinfo""' of type '""unsigned char [20]""'");
    19428     }
    19429   }
    19430   resultobj = SWIG_Py_Void();
    19431   return resultobj;
    19432 fail:
    19433   return NULL;
    19434 }
    19435 
    19436 
    19437 SWIGINTERN PyObject *_wrap_PTEID_PIC_facialinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19438   PyObject *resultobj = 0;
    19439   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19440   void *argp1 = 0 ;
    19441   int res1 = 0 ;
    19442   PyObject * obj0 = 0 ;
    19443   unsigned char *result = 0 ;
    19444  
    19445   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_facialinfo_get",1,1,&obj0)) SWIG_fail;
    19446   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19447   if (!SWIG_IsOK(res1)) {
    19448     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_facialinfo_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19449   }
    19450   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19451   result = (unsigned char *)(unsigned char *) ((arg1)->facialinfo);
    19452   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19453   return resultobj;
    19454 fail:
    19455   return NULL;
    19456 }
    19457 
    19458 
    19459 SWIGINTERN PyObject *_wrap_PTEID_PIC_imageinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19460   PyObject *resultobj = 0;
    19461   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19462   unsigned char *arg2 ;
    19463   void *argp1 = 0 ;
    19464   int res1 = 0 ;
    19465   void *argp2 = 0 ;
    19466   int res2 = 0 ;
    19467   PyObject * obj0 = 0 ;
    19468   PyObject * obj1 = 0 ;
    19469  
    19470   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_imageinfo_set",2,2,&obj0,&obj1)) SWIG_fail;
    19471   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19472   if (!SWIG_IsOK(res1)) {
    19473     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_imageinfo_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19474   }
    19475   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19476   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19477   if (!SWIG_IsOK(res2)) {
    19478     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_PIC_imageinfo_set" "', argument " "2"" of type '" "unsigned char [12]""'");
    19479   }
    19480   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19481   {
    19482     if (arg2) {
    19483       size_t ii = 0;
    19484       for (; ii < (size_t)12; ++ii) arg1->imageinfo[ii] = arg2[ii];
    19485     } else {
    19486       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""imageinfo""' of type '""unsigned char [12]""'");
    19487     }
    19488   }
    19489   resultobj = SWIG_Py_Void();
    19490   return resultobj;
    19491 fail:
    19492   return NULL;
    19493 }
    19494 
    19495 
    19496 SWIGINTERN PyObject *_wrap_PTEID_PIC_imageinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19497   PyObject *resultobj = 0;
    19498   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19499   void *argp1 = 0 ;
    19500   int res1 = 0 ;
    19501   PyObject * obj0 = 0 ;
    19502   unsigned char *result = 0 ;
    19503  
    19504   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_imageinfo_get",1,1,&obj0)) SWIG_fail;
    19505   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19506   if (!SWIG_IsOK(res1)) {
    19507     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_imageinfo_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19508   }
    19509   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19510   result = (unsigned char *)(unsigned char *) ((arg1)->imageinfo);
    19511   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19512   return resultobj;
    19513 fail:
    19514   return NULL;
    19515 }
    19516 
    19517 
    19518 SWIGINTERN PyObject *_wrap_PTEID_PIC_picture_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19519   PyObject *resultobj = 0;
    19520   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19521   unsigned char *arg2 ;
    19522   void *argp1 = 0 ;
    19523   int res1 = 0 ;
    19524   void *argp2 = 0 ;
    19525   int res2 = 0 ;
    19526   PyObject * obj0 = 0 ;
    19527   PyObject * obj1 = 0 ;
    19528  
    19529   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_picture_set",2,2,&obj0,&obj1)) SWIG_fail;
    19530   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19531   if (!SWIG_IsOK(res1)) {
    19532     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_picture_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19533   }
    19534   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19535   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19536   if (!SWIG_IsOK(res2)) {
    19537     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_PIC_picture_set" "', argument " "2"" of type '" "unsigned char [(14128+111)]""'");
    19538   }
    19539   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19540   {
    19541     if (arg2) {
    19542       size_t ii = 0;
    19543       for (; ii < (size_t)(14128+111); ++ii) arg1->picture[ii] = arg2[ii];
    19544     } else {
    19545       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""picture""' of type '""unsigned char [(14128+111)]""'");
    19546     }
    19547   }
    19548   resultobj = SWIG_Py_Void();
    19549   return resultobj;
    19550 fail:
    19551   return NULL;
    19552 }
    19553 
    19554 
    19555 SWIGINTERN PyObject *_wrap_PTEID_PIC_picture_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19556   PyObject *resultobj = 0;
    19557   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19558   void *argp1 = 0 ;
    19559   int res1 = 0 ;
    19560   PyObject * obj0 = 0 ;
    19561   unsigned char *result = 0 ;
    19562  
    19563   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_picture_get",1,1,&obj0)) SWIG_fail;
    19564   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19565   if (!SWIG_IsOK(res1)) {
    19566     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_picture_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19567   }
    19568   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19569   result = (unsigned char *)(unsigned char *) ((arg1)->picture);
    19570   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19571   return resultobj;
    19572 fail:
    19573   return NULL;
    19574 }
    19575 
    19576 
    19577 SWIGINTERN PyObject *_wrap_PTEID_PIC_piclength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19578   PyObject *resultobj = 0;
    19579   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19580   unsigned long arg2 ;
    19581   void *argp1 = 0 ;
    19582   int res1 = 0 ;
    19583   unsigned long val2 ;
    19584   int ecode2 = 0 ;
    19585   PyObject * obj0 = 0 ;
    19586   PyObject * obj1 = 0 ;
    19587  
    19588   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_piclength_set",2,2,&obj0,&obj1)) SWIG_fail;
    19589   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19590   if (!SWIG_IsOK(res1)) {
    19591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_piclength_set" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19592   }
    19593   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19594   ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
    19595   if (!SWIG_IsOK(ecode2)) {
    19596     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_PIC_piclength_set" "', argument " "2"" of type '" "unsigned long""'");
    19597   }
    19598   arg2 = static_cast< unsigned long >(val2);
    19599   if (arg1) (arg1)->piclength = arg2;
    19600   resultobj = SWIG_Py_Void();
    19601   return resultobj;
    19602 fail:
    19603   return NULL;
    19604 }
    19605 
    19606 
    19607 SWIGINTERN PyObject *_wrap_PTEID_PIC_piclength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19608   PyObject *resultobj = 0;
    19609   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19610   void *argp1 = 0 ;
    19611   int res1 = 0 ;
    19612   PyObject * obj0 = 0 ;
    19613   unsigned long result;
    19614  
    19615   if(!PyArg_UnpackTuple(args,(char *)"PTEID_PIC_piclength_get",1,1,&obj0)) SWIG_fail;
    19616   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    19617   if (!SWIG_IsOK(res1)) {
    19618     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_PIC_piclength_get" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19619   }
    19620   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19621   result = (unsigned long) ((arg1)->piclength);
    19622   resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
    19623   return resultobj;
    19624 fail:
    19625   return NULL;
    19626 }
    19627 
    19628 
    19629 SWIGINTERN PyObject *_wrap_new_PTEID_PIC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19630   PyObject *resultobj = 0;
    19631   eIDMW::PTEID_PIC *result = 0 ;
    19632  
    19633   result = (eIDMW::PTEID_PIC *)new eIDMW::PTEID_PIC();
    19634   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_PIC, SWIG_POINTER_NEW |  0 );
    19635   return resultobj;
    19636 fail:
    19637   return NULL;
    19638 }
    19639 
    19640 
    19641 SWIGINTERN PyObject *_wrap_delete_PTEID_PIC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19642   PyObject *resultobj = 0;
    19643   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    19644   void *argp1 = 0 ;
    19645   int res1 = 0 ;
    19646   PyObject * obj0 = 0 ;
    19647  
    19648   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_PIC",1,1,&obj0)) SWIG_fail;
    19649   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, SWIG_POINTER_DISOWN |  0 );
    19650   if (!SWIG_IsOK(res1)) {
    19651     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_PIC" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    19652   }
    19653   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    19654   delete arg1;
    19655   resultobj = SWIG_Py_Void();
    19656   return resultobj;
    19657 fail:
    19658   return NULL;
    19659 }
    19660 
    19661 
    19662 SWIGINTERN PyObject *PTEID_PIC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19663   PyObject *obj;
    19664   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    19665   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_PIC, SWIG_NewClientData(obj));
    19666   return SWIG_Py_Void();
    19667 }
    19668 
    19669 SWIGINTERN PyObject *_wrap_PTEID_Certif_certif_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19670   PyObject *resultobj = 0;
    19671   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19672   unsigned char *arg2 ;
    19673   void *argp1 = 0 ;
    19674   int res1 = 0 ;
    19675   void *argp2 = 0 ;
    19676   int res2 = 0 ;
    19677   PyObject * obj0 = 0 ;
    19678   PyObject * obj1 = 0 ;
    19679  
    19680   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certif_set",2,2,&obj0,&obj1)) SWIG_fail;
    19681   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19682   if (!SWIG_IsOK(res1)) {
    19683     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certif_set" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19684   }
    19685   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19686   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    19687   if (!SWIG_IsOK(res2)) {
    19688     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_Certif_certif_set" "', argument " "2"" of type '" "unsigned char [2500]""'");
    19689   }
    19690   arg2 = reinterpret_cast< unsigned char * >(argp2);
    19691   {
    19692     if (arg2) {
    19693       size_t ii = 0;
    19694       for (; ii < (size_t)2500; ++ii) arg1->certif[ii] = arg2[ii];
    19695     } else {
    19696       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""certif""' of type '""unsigned char [2500]""'");
    19697     }
    19698   }
    19699   resultobj = SWIG_Py_Void();
    19700   return resultobj;
    19701 fail:
    19702   return NULL;
    19703 }
    19704 
    19705 
    19706 SWIGINTERN PyObject *_wrap_PTEID_Certif_certif_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19707   PyObject *resultobj = 0;
    19708   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19709   void *argp1 = 0 ;
    19710   int res1 = 0 ;
    19711   PyObject * obj0 = 0 ;
    19712   unsigned char *result = 0 ;
    19713  
    19714   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certif_get",1,1,&obj0)) SWIG_fail;
    19715   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19716   if (!SWIG_IsOK(res1)) {
    19717     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certif_get" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19718   }
    19719   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19720   result = (unsigned char *)(unsigned char *) ((arg1)->certif);
    19721   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    19722   return resultobj;
    19723 fail:
    19724   return NULL;
    19725 }
    19726 
    19727 
    19728 SWIGINTERN PyObject *_wrap_PTEID_Certif_certifLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19729   PyObject *resultobj = 0;
    19730   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19731   long arg2 ;
    19732   void *argp1 = 0 ;
    19733   int res1 = 0 ;
    19734   long val2 ;
    19735   int ecode2 = 0 ;
    19736   PyObject * obj0 = 0 ;
    19737   PyObject * obj1 = 0 ;
    19738  
    19739   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certifLength_set",2,2,&obj0,&obj1)) SWIG_fail;
    19740   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19741   if (!SWIG_IsOK(res1)) {
    19742     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certifLength_set" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19743   }
    19744   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19745   ecode2 = SWIG_AsVal_long(obj1, &val2);
    19746   if (!SWIG_IsOK(ecode2)) {
    19747     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_Certif_certifLength_set" "', argument " "2"" of type '" "long""'");
    19748   }
    19749   arg2 = static_cast< long >(val2);
    19750   if (arg1) (arg1)->certifLength = arg2;
    19751   resultobj = SWIG_Py_Void();
    19752   return resultobj;
    19753 fail:
    19754   return NULL;
    19755 }
    19756 
    19757 
    19758 SWIGINTERN PyObject *_wrap_PTEID_Certif_certifLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19759   PyObject *resultobj = 0;
    19760   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19761   void *argp1 = 0 ;
    19762   int res1 = 0 ;
    19763   PyObject * obj0 = 0 ;
    19764   long result;
    19765  
    19766   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certifLength_get",1,1,&obj0)) SWIG_fail;
    19767   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19768   if (!SWIG_IsOK(res1)) {
    19769     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certifLength_get" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19770   }
    19771   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19772   result = (long) ((arg1)->certifLength);
    19773   resultobj = SWIG_From_long(static_cast< long >(result));
    19774   return resultobj;
    19775 fail:
    19776   return NULL;
    19777 }
    19778 
    19779 
    19780 SWIGINTERN PyObject *_wrap_PTEID_Certif_certifLabel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19781   PyObject *resultobj = 0;
    19782   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19783   char *arg2 ;
    19784   void *argp1 = 0 ;
    19785   int res1 = 0 ;
    19786   char temp2[256] ;
    19787   int res2 ;
    19788   PyObject * obj0 = 0 ;
    19789   PyObject * obj1 = 0 ;
    19790  
    19791   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certifLabel_set",2,2,&obj0,&obj1)) SWIG_fail;
    19792   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19793   if (!SWIG_IsOK(res1)) {
    19794     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certifLabel_set" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19795   }
    19796   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19797   res2 = SWIG_AsCharArray(obj1, temp2, 256);
    19798   if (!SWIG_IsOK(res2)) {
    19799     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_Certif_certifLabel_set" "', argument " "2"" of type '" "char [256]""'");
    19800   }
    19801   arg2 = reinterpret_cast< char * >(temp2);
    19802   if (arg2) memcpy(arg1->certifLabel,arg2,256*sizeof(char));
    19803   else memset(arg1->certifLabel,0,256*sizeof(char));
    19804   resultobj = SWIG_Py_Void();
    19805   return resultobj;
    19806 fail:
    19807   return NULL;
    19808 }
    19809 
    19810 
    19811 SWIGINTERN PyObject *_wrap_PTEID_Certif_certifLabel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19812   PyObject *resultobj = 0;
    19813   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19814   void *argp1 = 0 ;
    19815   int res1 = 0 ;
    19816   PyObject * obj0 = 0 ;
    19817   char *result = 0 ;
    19818  
    19819   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certif_certifLabel_get",1,1,&obj0)) SWIG_fail;
    19820   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19821   if (!SWIG_IsOK(res1)) {
    19822     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certif_certifLabel_get" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19823   }
    19824   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19825   result = (char *)(char *) ((arg1)->certifLabel);
    19826   {
    19827     size_t size = 256;
    19828    
    19829     while (size && (result[size - 1] == '\0')) --size;
    19830    
    19831     resultobj = SWIG_FromCharPtrAndSize(result, size);
    19832   }
    19833   return resultobj;
    19834 fail:
    19835   return NULL;
    19836 }
    19837 
    19838 
    19839 SWIGINTERN PyObject *_wrap_new_PTEID_Certif(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19840   PyObject *resultobj = 0;
    19841   eIDMW::PTEID_Certif *result = 0 ;
    19842  
    19843   result = (eIDMW::PTEID_Certif *)new eIDMW::PTEID_Certif();
    19844   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_Certif, SWIG_POINTER_NEW |  0 );
    19845   return resultobj;
    19846 fail:
    19847   return NULL;
    19848 }
    19849 
    19850 
    19851 SWIGINTERN PyObject *_wrap_delete_PTEID_Certif(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19852   PyObject *resultobj = 0;
    19853   eIDMW::PTEID_Certif *arg1 = (eIDMW::PTEID_Certif *) 0 ;
    19854   void *argp1 = 0 ;
    19855   int res1 = 0 ;
    19856   PyObject * obj0 = 0 ;
    19857  
    19858   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_Certif",1,1,&obj0)) SWIG_fail;
    19859   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certif, SWIG_POINTER_DISOWN |  0 );
    19860   if (!SWIG_IsOK(res1)) {
    19861     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_Certif" "', argument " "1"" of type '" "eIDMW::PTEID_Certif *""'");
    19862   }
    19863   arg1 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp1);
    19864   delete arg1;
    19865   resultobj = SWIG_Py_Void();
    19866   return resultobj;
    19867 fail:
    19868   return NULL;
    19869 }
    19870 
    19871 
    19872 SWIGINTERN PyObject *PTEID_Certif_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19873   PyObject *obj;
    19874   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    19875   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_Certif, SWIG_NewClientData(obj));
    19876   return SWIG_Py_Void();
    19877 }
    19878 
    19879 SWIGINTERN PyObject *_wrap_PTEID_Certifs_certificates_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19880   PyObject *resultobj = 0;
    19881   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    19882   eIDMW::PTEID_Certif *arg2 ;
    19883   void *argp1 = 0 ;
    19884   int res1 = 0 ;
    19885   void *argp2 = 0 ;
    19886   int res2 = 0 ;
    19887   PyObject * obj0 = 0 ;
    19888   PyObject * obj1 = 0 ;
    19889  
    19890   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certifs_certificates_set",2,2,&obj0,&obj1)) SWIG_fail;
    19891   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    19892   if (!SWIG_IsOK(res1)) {
    19893     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certifs_certificates_set" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    19894   }
    19895   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    19896   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19897   if (!SWIG_IsOK(res2)) {
    19898     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_Certifs_certificates_set" "', argument " "2"" of type '" "eIDMW::PTEID_Certif [10]""'");
    19899   }
    19900   arg2 = reinterpret_cast< eIDMW::PTEID_Certif * >(argp2);
    19901   {
    19902     if (arg2) {
    19903       size_t ii = 0;
    19904       for (; ii < (size_t)10; ++ii) arg1->certificates[ii] = arg2[ii];
    19905     } else {
    19906       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""certificates""' of type '""eIDMW::PTEID_Certif [10]""'");
    19907     }
    19908   }
    19909   resultobj = SWIG_Py_Void();
    19910   return resultobj;
    19911 fail:
    19912   return NULL;
    19913 }
    19914 
    19915 
    19916 SWIGINTERN PyObject *_wrap_PTEID_Certifs_certificates_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19917   PyObject *resultobj = 0;
    19918   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    19919   void *argp1 = 0 ;
    19920   int res1 = 0 ;
    19921   PyObject * obj0 = 0 ;
    19922   eIDMW::PTEID_Certif *result = 0 ;
    19923  
    19924   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certifs_certificates_get",1,1,&obj0)) SWIG_fail;
    19925   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    19926   if (!SWIG_IsOK(res1)) {
    19927     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certifs_certificates_get" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    19928   }
    19929   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    19930   result = (eIDMW::PTEID_Certif *)(eIDMW::PTEID_Certif *) ((arg1)->certificates);
    19931   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_Certif, 0 |  0 );
    19932   return resultobj;
    19933 fail:
    19934   return NULL;
    19935 }
    19936 
    19937 
    19938 SWIGINTERN PyObject *_wrap_PTEID_Certifs_certificatesLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19939   PyObject *resultobj = 0;
    19940   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    19941   long arg2 ;
    19942   void *argp1 = 0 ;
    19943   int res1 = 0 ;
    19944   long val2 ;
    19945   int ecode2 = 0 ;
    19946   PyObject * obj0 = 0 ;
    19947   PyObject * obj1 = 0 ;
    19948  
    19949   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certifs_certificatesLength_set",2,2,&obj0,&obj1)) SWIG_fail;
    19950   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    19951   if (!SWIG_IsOK(res1)) {
    19952     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certifs_certificatesLength_set" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    19953   }
    19954   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    19955   ecode2 = SWIG_AsVal_long(obj1, &val2);
    19956   if (!SWIG_IsOK(ecode2)) {
    19957     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_Certifs_certificatesLength_set" "', argument " "2"" of type '" "long""'");
    19958   }
    19959   arg2 = static_cast< long >(val2);
    19960   if (arg1) (arg1)->certificatesLength = arg2;
    19961   resultobj = SWIG_Py_Void();
    19962   return resultobj;
    19963 fail:
    19964   return NULL;
    19965 }
    19966 
    19967 
    19968 SWIGINTERN PyObject *_wrap_PTEID_Certifs_certificatesLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19969   PyObject *resultobj = 0;
    19970   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    19971   void *argp1 = 0 ;
    19972   int res1 = 0 ;
    19973   PyObject * obj0 = 0 ;
    19974   long result;
    19975  
    19976   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Certifs_certificatesLength_get",1,1,&obj0)) SWIG_fail;
    19977   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    19978   if (!SWIG_IsOK(res1)) {
    19979     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Certifs_certificatesLength_get" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    19980   }
    19981   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    19982   result = (long) ((arg1)->certificatesLength);
    19983   resultobj = SWIG_From_long(static_cast< long >(result));
    19984   return resultobj;
    19985 fail:
    19986   return NULL;
    19987 }
    19988 
    19989 
    19990 SWIGINTERN PyObject *_wrap_new_PTEID_Certifs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    19991   PyObject *resultobj = 0;
    19992   eIDMW::PTEID_Certifs *result = 0 ;
    19993  
    19994   result = (eIDMW::PTEID_Certifs *)new eIDMW::PTEID_Certifs();
    19995   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_Certifs, SWIG_POINTER_NEW |  0 );
    19996   return resultobj;
    19997 fail:
    19998   return NULL;
    19999 }
    20000 
    20001 
    20002 SWIGINTERN PyObject *_wrap_delete_PTEID_Certifs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20003   PyObject *resultobj = 0;
    20004   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    20005   void *argp1 = 0 ;
    20006   int res1 = 0 ;
    20007   PyObject * obj0 = 0 ;
    20008  
    20009   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_Certifs",1,1,&obj0)) SWIG_fail;
    20010   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, SWIG_POINTER_DISOWN |  0 );
    20011   if (!SWIG_IsOK(res1)) {
    20012     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_Certifs" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    20013   }
    20014   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    20015   delete arg1;
    20016   resultobj = SWIG_Py_Void();
    20017   return resultobj;
    20018 fail:
    20019   return NULL;
    20020 }
    20021 
    20022 
    20023 SWIGINTERN PyObject *PTEID_Certifs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20024   PyObject *obj;
    20025   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    20026   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_Certifs, SWIG_NewClientData(obj));
    20027   return SWIG_Py_Void();
    20028 }
    20029 
    20030 SWIGINTERN PyObject *_wrap_PTEIDPin_pinType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20031   PyObject *resultobj = 0;
    20032   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20033   long arg2 ;
    20034   void *argp1 = 0 ;
    20035   int res1 = 0 ;
    20036   long val2 ;
    20037   int ecode2 = 0 ;
    20038   PyObject * obj0 = 0 ;
    20039   PyObject * obj1 = 0 ;
    20040  
    20041   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_pinType_set",2,2,&obj0,&obj1)) SWIG_fail;
    20042   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20043   if (!SWIG_IsOK(res1)) {
    20044     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_pinType_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20045   }
    20046   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20047   ecode2 = SWIG_AsVal_long(obj1, &val2);
    20048   if (!SWIG_IsOK(ecode2)) {
    20049     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPin_pinType_set" "', argument " "2"" of type '" "long""'");
    20050   }
    20051   arg2 = static_cast< long >(val2);
    20052   if (arg1) (arg1)->pinType = arg2;
    20053   resultobj = SWIG_Py_Void();
    20054   return resultobj;
    20055 fail:
    20056   return NULL;
    20057 }
    20058 
    20059 
    20060 SWIGINTERN PyObject *_wrap_PTEIDPin_pinType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20061   PyObject *resultobj = 0;
    20062   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20063   void *argp1 = 0 ;
    20064   int res1 = 0 ;
    20065   PyObject * obj0 = 0 ;
    20066   long result;
    20067  
    20068   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_pinType_get",1,1,&obj0)) SWIG_fail;
    20069   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20070   if (!SWIG_IsOK(res1)) {
    20071     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_pinType_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20072   }
    20073   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20074   result = (long) ((arg1)->pinType);
    20075   resultobj = SWIG_From_long(static_cast< long >(result));
    20076   return resultobj;
    20077 fail:
    20078   return NULL;
    20079 }
    20080 
    20081 
    20082 SWIGINTERN PyObject *_wrap_PTEIDPin_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20083   PyObject *resultobj = 0;
    20084   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20085   unsigned char arg2 ;
    20086   void *argp1 = 0 ;
    20087   int res1 = 0 ;
    20088   unsigned char val2 ;
    20089   int ecode2 = 0 ;
    20090   PyObject * obj0 = 0 ;
    20091   PyObject * obj1 = 0 ;
    20092  
    20093   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_id_set",2,2,&obj0,&obj1)) SWIG_fail;
    20094   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20095   if (!SWIG_IsOK(res1)) {
    20096     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_id_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20097   }
    20098   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20099   ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
    20100   if (!SWIG_IsOK(ecode2)) {
    20101     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPin_id_set" "', argument " "2"" of type '" "unsigned char""'");
    20102   }
    20103   arg2 = static_cast< unsigned char >(val2);
    20104   if (arg1) (arg1)->id = arg2;
    20105   resultobj = SWIG_Py_Void();
    20106   return resultobj;
    20107 fail:
    20108   return NULL;
    20109 }
    20110 
    20111 
    20112 SWIGINTERN PyObject *_wrap_PTEIDPin_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20113   PyObject *resultobj = 0;
    20114   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20115   void *argp1 = 0 ;
    20116   int res1 = 0 ;
    20117   PyObject * obj0 = 0 ;
    20118   unsigned char result;
    20119  
    20120   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_id_get",1,1,&obj0)) SWIG_fail;
    20121   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20122   if (!SWIG_IsOK(res1)) {
    20123     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_id_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20124   }
    20125   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20126   result = (unsigned char) ((arg1)->id);
    20127   resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
    20128   return resultobj;
    20129 fail:
    20130   return NULL;
    20131 }
    20132 
    20133 
    20134 SWIGINTERN PyObject *_wrap_PTEIDPin_usageCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20135   PyObject *resultobj = 0;
    20136   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20137   long arg2 ;
    20138   void *argp1 = 0 ;
    20139   int res1 = 0 ;
    20140   long val2 ;
    20141   int ecode2 = 0 ;
    20142   PyObject * obj0 = 0 ;
    20143   PyObject * obj1 = 0 ;
    20144  
    20145   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_usageCode_set",2,2,&obj0,&obj1)) SWIG_fail;
    20146   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20147   if (!SWIG_IsOK(res1)) {
    20148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_usageCode_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20149   }
    20150   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20151   ecode2 = SWIG_AsVal_long(obj1, &val2);
    20152   if (!SWIG_IsOK(ecode2)) {
    20153     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPin_usageCode_set" "', argument " "2"" of type '" "long""'");
    20154   }
    20155   arg2 = static_cast< long >(val2);
    20156   if (arg1) (arg1)->usageCode = arg2;
    20157   resultobj = SWIG_Py_Void();
    20158   return resultobj;
    20159 fail:
    20160   return NULL;
    20161 }
    20162 
    20163 
    20164 SWIGINTERN PyObject *_wrap_PTEIDPin_usageCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20165   PyObject *resultobj = 0;
    20166   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20167   void *argp1 = 0 ;
    20168   int res1 = 0 ;
    20169   PyObject * obj0 = 0 ;
    20170   long result;
    20171  
    20172   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_usageCode_get",1,1,&obj0)) SWIG_fail;
    20173   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20174   if (!SWIG_IsOK(res1)) {
    20175     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_usageCode_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20176   }
    20177   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20178   result = (long) ((arg1)->usageCode);
    20179   resultobj = SWIG_From_long(static_cast< long >(result));
    20180   return resultobj;
    20181 fail:
    20182   return NULL;
    20183 }
    20184 
    20185 
    20186 SWIGINTERN PyObject *_wrap_PTEIDPin_triesLeft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20187   PyObject *resultobj = 0;
    20188   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20189   long arg2 ;
    20190   void *argp1 = 0 ;
    20191   int res1 = 0 ;
    20192   long val2 ;
    20193   int ecode2 = 0 ;
    20194   PyObject * obj0 = 0 ;
    20195   PyObject * obj1 = 0 ;
    20196  
    20197   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_triesLeft_set",2,2,&obj0,&obj1)) SWIG_fail;
    20198   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20199   if (!SWIG_IsOK(res1)) {
    20200     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_triesLeft_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20201   }
    20202   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20203   ecode2 = SWIG_AsVal_long(obj1, &val2);
    20204   if (!SWIG_IsOK(ecode2)) {
    20205     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPin_triesLeft_set" "', argument " "2"" of type '" "long""'");
    20206   }
    20207   arg2 = static_cast< long >(val2);
    20208   if (arg1) (arg1)->triesLeft = arg2;
    20209   resultobj = SWIG_Py_Void();
    20210   return resultobj;
    20211 fail:
    20212   return NULL;
    20213 }
    20214 
    20215 
    20216 SWIGINTERN PyObject *_wrap_PTEIDPin_triesLeft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20217   PyObject *resultobj = 0;
    20218   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20219   void *argp1 = 0 ;
    20220   int res1 = 0 ;
    20221   PyObject * obj0 = 0 ;
    20222   long result;
    20223  
    20224   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_triesLeft_get",1,1,&obj0)) SWIG_fail;
    20225   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20226   if (!SWIG_IsOK(res1)) {
    20227     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_triesLeft_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20228   }
    20229   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20230   result = (long) ((arg1)->triesLeft);
    20231   resultobj = SWIG_From_long(static_cast< long >(result));
    20232   return resultobj;
    20233 fail:
    20234   return NULL;
    20235 }
    20236 
    20237 
    20238 SWIGINTERN PyObject *_wrap_PTEIDPin_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20239   PyObject *resultobj = 0;
    20240   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20241   long arg2 ;
    20242   void *argp1 = 0 ;
    20243   int res1 = 0 ;
    20244   long val2 ;
    20245   int ecode2 = 0 ;
    20246   PyObject * obj0 = 0 ;
    20247   PyObject * obj1 = 0 ;
    20248  
    20249   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_flags_set",2,2,&obj0,&obj1)) SWIG_fail;
    20250   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20251   if (!SWIG_IsOK(res1)) {
    20252     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_flags_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20253   }
    20254   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20255   ecode2 = SWIG_AsVal_long(obj1, &val2);
    20256   if (!SWIG_IsOK(ecode2)) {
    20257     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPin_flags_set" "', argument " "2"" of type '" "long""'");
    20258   }
    20259   arg2 = static_cast< long >(val2);
    20260   if (arg1) (arg1)->flags = arg2;
    20261   resultobj = SWIG_Py_Void();
    20262   return resultobj;
    20263 fail:
    20264   return NULL;
    20265 }
    20266 
    20267 
    20268 SWIGINTERN PyObject *_wrap_PTEIDPin_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20269   PyObject *resultobj = 0;
    20270   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20271   void *argp1 = 0 ;
    20272   int res1 = 0 ;
    20273   PyObject * obj0 = 0 ;
    20274   long result;
    20275  
    20276   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_flags_get",1,1,&obj0)) SWIG_fail;
    20277   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20278   if (!SWIG_IsOK(res1)) {
    20279     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_flags_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20280   }
    20281   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20282   result = (long) ((arg1)->flags);
    20283   resultobj = SWIG_From_long(static_cast< long >(result));
    20284   return resultobj;
    20285 fail:
    20286   return NULL;
    20287 }
    20288 
    20289 
    20290 SWIGINTERN PyObject *_wrap_PTEIDPin_label_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20291   PyObject *resultobj = 0;
    20292   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20293   char *arg2 ;
    20294   void *argp1 = 0 ;
    20295   int res1 = 0 ;
    20296   char temp2[256] ;
    20297   int res2 ;
    20298   PyObject * obj0 = 0 ;
    20299   PyObject * obj1 = 0 ;
    20300  
    20301   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_label_set",2,2,&obj0,&obj1)) SWIG_fail;
    20302   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20303   if (!SWIG_IsOK(res1)) {
    20304     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_label_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20305   }
    20306   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20307   res2 = SWIG_AsCharArray(obj1, temp2, 256);
    20308   if (!SWIG_IsOK(res2)) {
    20309     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEIDPin_label_set" "', argument " "2"" of type '" "char [256]""'");
    20310   }
    20311   arg2 = reinterpret_cast< char * >(temp2);
    20312   if (arg2) memcpy(arg1->label,arg2,256*sizeof(char));
    20313   else memset(arg1->label,0,256*sizeof(char));
    20314   resultobj = SWIG_Py_Void();
    20315   return resultobj;
    20316 fail:
    20317   return NULL;
    20318 }
    20319 
    20320 
    20321 SWIGINTERN PyObject *_wrap_PTEIDPin_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20322   PyObject *resultobj = 0;
    20323   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20324   void *argp1 = 0 ;
    20325   int res1 = 0 ;
    20326   PyObject * obj0 = 0 ;
    20327   char *result = 0 ;
    20328  
    20329   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_label_get",1,1,&obj0)) SWIG_fail;
    20330   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20331   if (!SWIG_IsOK(res1)) {
    20332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_label_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20333   }
    20334   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20335   result = (char *)(char *) ((arg1)->label);
    20336   {
    20337     size_t size = 256;
    20338    
    20339     while (size && (result[size - 1] == '\0')) --size;
    20340    
    20341     resultobj = SWIG_FromCharPtrAndSize(result, size);
    20342   }
    20343   return resultobj;
    20344 fail:
    20345   return NULL;
    20346 }
    20347 
    20348 
    20349 SWIGINTERN PyObject *_wrap_PTEIDPin_shortUsage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20350   PyObject *resultobj = 0;
    20351   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20352   char *arg2 = (char *) 0 ;
    20353   void *argp1 = 0 ;
    20354   int res1 = 0 ;
    20355   int res2 ;
    20356   char *buf2 = 0 ;
    20357   int alloc2 = 0 ;
    20358   PyObject * obj0 = 0 ;
    20359   PyObject * obj1 = 0 ;
    20360  
    20361   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_shortUsage_set",2,2,&obj0,&obj1)) SWIG_fail;
    20362   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20363   if (!SWIG_IsOK(res1)) {
    20364     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_shortUsage_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20365   }
    20366   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20367   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    20368   if (!SWIG_IsOK(res2)) {
    20369     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEIDPin_shortUsage_set" "', argument " "2"" of type '" "char *""'");
    20370   }
    20371   arg2 = reinterpret_cast< char * >(buf2);
    20372   if (arg1->shortUsage) delete[] arg1->shortUsage;
    20373   if (arg2) {
    20374     size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    20375     arg1->shortUsage = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
    20376   } else {
    20377     arg1->shortUsage = 0;
    20378   }
    20379   resultobj = SWIG_Py_Void();
    20380   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    20381   return resultobj;
    20382 fail:
    20383   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    20384   return NULL;
    20385 }
    20386 
    20387 
    20388 SWIGINTERN PyObject *_wrap_PTEIDPin_shortUsage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20389   PyObject *resultobj = 0;
    20390   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20391   void *argp1 = 0 ;
    20392   int res1 = 0 ;
    20393   PyObject * obj0 = 0 ;
    20394   char *result = 0 ;
    20395  
    20396   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_shortUsage_get",1,1,&obj0)) SWIG_fail;
    20397   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20398   if (!SWIG_IsOK(res1)) {
    20399     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_shortUsage_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20400   }
    20401   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20402   result = (char *) ((arg1)->shortUsage);
    20403   resultobj = SWIG_FromCharPtr((const char *)result);
    20404   return resultobj;
    20405 fail:
    20406   return NULL;
    20407 }
    20408 
    20409 
    20410 SWIGINTERN PyObject *_wrap_PTEIDPin_longUsage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20411   PyObject *resultobj = 0;
    20412   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20413   char *arg2 = (char *) 0 ;
    20414   void *argp1 = 0 ;
    20415   int res1 = 0 ;
    20416   int res2 ;
    20417   char *buf2 = 0 ;
    20418   int alloc2 = 0 ;
    20419   PyObject * obj0 = 0 ;
    20420   PyObject * obj1 = 0 ;
    20421  
    20422   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_longUsage_set",2,2,&obj0,&obj1)) SWIG_fail;
    20423   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20424   if (!SWIG_IsOK(res1)) {
    20425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_longUsage_set" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20426   }
    20427   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20428   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    20429   if (!SWIG_IsOK(res2)) {
    20430     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEIDPin_longUsage_set" "', argument " "2"" of type '" "char *""'");
    20431   }
    20432   arg2 = reinterpret_cast< char * >(buf2);
    20433   if (arg1->longUsage) delete[] arg1->longUsage;
    20434   if (arg2) {
    20435     size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    20436     arg1->longUsage = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
    20437   } else {
    20438     arg1->longUsage = 0;
    20439   }
    20440   resultobj = SWIG_Py_Void();
    20441   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    20442   return resultobj;
    20443 fail:
    20444   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    20445   return NULL;
    20446 }
    20447 
    20448 
    20449 SWIGINTERN PyObject *_wrap_PTEIDPin_longUsage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20450   PyObject *resultobj = 0;
    20451   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20452   void *argp1 = 0 ;
    20453   int res1 = 0 ;
    20454   PyObject * obj0 = 0 ;
    20455   char *result = 0 ;
    20456  
    20457   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPin_longUsage_get",1,1,&obj0)) SWIG_fail;
    20458   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20459   if (!SWIG_IsOK(res1)) {
    20460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPin_longUsage_get" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20461   }
    20462   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20463   result = (char *) ((arg1)->longUsage);
    20464   resultobj = SWIG_FromCharPtr((const char *)result);
    20465   return resultobj;
    20466 fail:
    20467   return NULL;
    20468 }
    20469 
    20470 
    20471 SWIGINTERN PyObject *_wrap_new_PTEIDPin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20472   PyObject *resultobj = 0;
    20473   eIDMW::PTEIDPin *result = 0 ;
    20474  
    20475   result = (eIDMW::PTEIDPin *)new eIDMW::PTEIDPin();
    20476   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEIDPin, SWIG_POINTER_NEW |  0 );
    20477   return resultobj;
    20478 fail:
    20479   return NULL;
    20480 }
    20481 
    20482 
    20483 SWIGINTERN PyObject *_wrap_delete_PTEIDPin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20484   PyObject *resultobj = 0;
    20485   eIDMW::PTEIDPin *arg1 = (eIDMW::PTEIDPin *) 0 ;
    20486   void *argp1 = 0 ;
    20487   int res1 = 0 ;
    20488   PyObject * obj0 = 0 ;
    20489  
    20490   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEIDPin",1,1,&obj0)) SWIG_fail;
    20491   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPin, SWIG_POINTER_DISOWN |  0 );
    20492   if (!SWIG_IsOK(res1)) {
    20493     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEIDPin" "', argument " "1"" of type '" "eIDMW::PTEIDPin *""'");
    20494   }
    20495   arg1 = reinterpret_cast< eIDMW::PTEIDPin * >(argp1);
    20496   delete arg1;
    20497   resultobj = SWIG_Py_Void();
    20498   return resultobj;
    20499 fail:
    20500   return NULL;
    20501 }
    20502 
    20503 
    20504 SWIGINTERN PyObject *PTEIDPin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20505   PyObject *obj;
    20506   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    20507   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEIDPin, SWIG_NewClientData(obj));
    20508   return SWIG_Py_Void();
    20509 }
    20510 
    20511 SWIGINTERN PyObject *_wrap_PTEIDPins_pins_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20512   PyObject *resultobj = 0;
    20513   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    20514   eIDMW::PTEIDPin *arg2 ;
    20515   void *argp1 = 0 ;
    20516   int res1 = 0 ;
    20517   void *argp2 = 0 ;
    20518   int res2 = 0 ;
    20519   PyObject * obj0 = 0 ;
    20520   PyObject * obj1 = 0 ;
    20521  
    20522   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPins_pins_set",2,2,&obj0,&obj1)) SWIG_fail;
    20523   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, 0 |  0 );
    20524   if (!SWIG_IsOK(res1)) {
    20525     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPins_pins_set" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    20526   }
    20527   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    20528   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20529   if (!SWIG_IsOK(res2)) {
    20530     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEIDPins_pins_set" "', argument " "2"" of type '" "eIDMW::PTEIDPin [8]""'");
    20531   }
    20532   arg2 = reinterpret_cast< eIDMW::PTEIDPin * >(argp2);
    20533   {
    20534     if (arg2) {
    20535       size_t ii = 0;
    20536       for (; ii < (size_t)8; ++ii) arg1->pins[ii] = arg2[ii];
    20537     } else {
    20538       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pins""' of type '""eIDMW::PTEIDPin [8]""'");
    20539     }
    20540   }
    20541   resultobj = SWIG_Py_Void();
    20542   return resultobj;
    20543 fail:
    20544   return NULL;
    20545 }
    20546 
    20547 
    20548 SWIGINTERN PyObject *_wrap_PTEIDPins_pins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20549   PyObject *resultobj = 0;
    20550   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    20551   void *argp1 = 0 ;
    20552   int res1 = 0 ;
    20553   PyObject * obj0 = 0 ;
    20554   eIDMW::PTEIDPin *result = 0 ;
    20555  
    20556   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPins_pins_get",1,1,&obj0)) SWIG_fail;
    20557   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, 0 |  0 );
    20558   if (!SWIG_IsOK(res1)) {
    20559     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPins_pins_get" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    20560   }
    20561   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    20562   result = (eIDMW::PTEIDPin *)(eIDMW::PTEIDPin *) ((arg1)->pins);
    20563   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEIDPin, 0 |  0 );
    20564   return resultobj;
    20565 fail:
    20566   return NULL;
    20567 }
    20568 
    20569 
    20570 SWIGINTERN PyObject *_wrap_PTEIDPins_pinsLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20571   PyObject *resultobj = 0;
    20572   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    20573   long arg2 ;
    20574   void *argp1 = 0 ;
    20575   int res1 = 0 ;
    20576   long val2 ;
    20577   int ecode2 = 0 ;
    20578   PyObject * obj0 = 0 ;
    20579   PyObject * obj1 = 0 ;
    20580  
    20581   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPins_pinsLength_set",2,2,&obj0,&obj1)) SWIG_fail;
    20582   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, 0 |  0 );
    20583   if (!SWIG_IsOK(res1)) {
    20584     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPins_pinsLength_set" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    20585   }
    20586   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    20587   ecode2 = SWIG_AsVal_long(obj1, &val2);
    20588   if (!SWIG_IsOK(ecode2)) {
    20589     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEIDPins_pinsLength_set" "', argument " "2"" of type '" "long""'");
    20590   }
    20591   arg2 = static_cast< long >(val2);
    20592   if (arg1) (arg1)->pinsLength = arg2;
    20593   resultobj = SWIG_Py_Void();
    20594   return resultobj;
    20595 fail:
    20596   return NULL;
    20597 }
    20598 
    20599 
    20600 SWIGINTERN PyObject *_wrap_PTEIDPins_pinsLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20601   PyObject *resultobj = 0;
    20602   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    20603   void *argp1 = 0 ;
    20604   int res1 = 0 ;
    20605   PyObject * obj0 = 0 ;
    20606   long result;
    20607  
    20608   if(!PyArg_UnpackTuple(args,(char *)"PTEIDPins_pinsLength_get",1,1,&obj0)) SWIG_fail;
    20609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, 0 |  0 );
    20610   if (!SWIG_IsOK(res1)) {
    20611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEIDPins_pinsLength_get" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    20612   }
    20613   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    20614   result = (long) ((arg1)->pinsLength);
    20615   resultobj = SWIG_From_long(static_cast< long >(result));
    20616   return resultobj;
    20617 fail:
    20618   return NULL;
    20619 }
    20620 
    20621 
    20622 SWIGINTERN PyObject *_wrap_new_PTEIDPins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20623   PyObject *resultobj = 0;
    20624   eIDMW::PTEIDPins *result = 0 ;
    20625  
    20626   result = (eIDMW::PTEIDPins *)new eIDMW::PTEIDPins();
    20627   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEIDPins, SWIG_POINTER_NEW |  0 );
    20628   return resultobj;
    20629 fail:
    20630   return NULL;
    20631 }
    20632 
    20633 
    20634 SWIGINTERN PyObject *_wrap_delete_PTEIDPins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20635   PyObject *resultobj = 0;
    20636   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    20637   void *argp1 = 0 ;
    20638   int res1 = 0 ;
    20639   PyObject * obj0 = 0 ;
    20640  
    20641   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEIDPins",1,1,&obj0)) SWIG_fail;
    20642   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, SWIG_POINTER_DISOWN |  0 );
    20643   if (!SWIG_IsOK(res1)) {
    20644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEIDPins" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    20645   }
    20646   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    20647   delete arg1;
    20648   resultobj = SWIG_Py_Void();
    20649   return resultobj;
    20650 fail:
    20651   return NULL;
    20652 }
    20653 
    20654 
    20655 SWIGINTERN PyObject *PTEIDPins_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20656   PyObject *obj;
    20657   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    20658   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEIDPins, SWIG_NewClientData(obj));
    20659   return SWIG_Py_Void();
    20660 }
    20661 
    20662 SWIGINTERN PyObject *_wrap_PTEID_TokenInfo_label_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20663   PyObject *resultobj = 0;
    20664   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    20665   char *arg2 ;
    20666   void *argp1 = 0 ;
    20667   int res1 = 0 ;
    20668   char temp2[256] ;
    20669   int res2 ;
    20670   PyObject * obj0 = 0 ;
    20671   PyObject * obj1 = 0 ;
    20672  
    20673   if(!PyArg_UnpackTuple(args,(char *)"PTEID_TokenInfo_label_set",2,2,&obj0,&obj1)) SWIG_fail;
    20674   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, 0 |  0 );
    20675   if (!SWIG_IsOK(res1)) {
    20676     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_TokenInfo_label_set" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    20677   }
    20678   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    20679   res2 = SWIG_AsCharArray(obj1, temp2, 256);
    20680   if (!SWIG_IsOK(res2)) {
    20681     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_TokenInfo_label_set" "', argument " "2"" of type '" "char [256]""'");
    20682   }
    20683   arg2 = reinterpret_cast< char * >(temp2);
    20684   if (arg2) memcpy(arg1->label,arg2,256*sizeof(char));
    20685   else memset(arg1->label,0,256*sizeof(char));
    20686   resultobj = SWIG_Py_Void();
    20687   return resultobj;
    20688 fail:
    20689   return NULL;
    20690 }
    20691 
    20692 
    20693 SWIGINTERN PyObject *_wrap_PTEID_TokenInfo_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20694   PyObject *resultobj = 0;
    20695   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    20696   void *argp1 = 0 ;
    20697   int res1 = 0 ;
    20698   PyObject * obj0 = 0 ;
    20699   char *result = 0 ;
    20700  
    20701   if(!PyArg_UnpackTuple(args,(char *)"PTEID_TokenInfo_label_get",1,1,&obj0)) SWIG_fail;
    20702   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, 0 |  0 );
    20703   if (!SWIG_IsOK(res1)) {
    20704     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_TokenInfo_label_get" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    20705   }
    20706   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    20707   result = (char *)(char *) ((arg1)->label);
    20708   {
    20709     size_t size = 256;
    20710    
    20711     while (size && (result[size - 1] == '\0')) --size;
    20712    
    20713     resultobj = SWIG_FromCharPtrAndSize(result, size);
    20714   }
    20715   return resultobj;
    20716 fail:
    20717   return NULL;
    20718 }
    20719 
    20720 
    20721 SWIGINTERN PyObject *_wrap_PTEID_TokenInfo_serial_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20722   PyObject *resultobj = 0;
    20723   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    20724   char *arg2 ;
    20725   void *argp1 = 0 ;
    20726   int res1 = 0 ;
    20727   char temp2[64] ;
    20728   int res2 ;
    20729   PyObject * obj0 = 0 ;
    20730   PyObject * obj1 = 0 ;
    20731  
    20732   if(!PyArg_UnpackTuple(args,(char *)"PTEID_TokenInfo_serial_set",2,2,&obj0,&obj1)) SWIG_fail;
    20733   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, 0 |  0 );
    20734   if (!SWIG_IsOK(res1)) {
    20735     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_TokenInfo_serial_set" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    20736   }
    20737   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    20738   res2 = SWIG_AsCharArray(obj1, temp2, 64);
    20739   if (!SWIG_IsOK(res2)) {
    20740     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_TokenInfo_serial_set" "', argument " "2"" of type '" "char [64]""'");
    20741   }
    20742   arg2 = reinterpret_cast< char * >(temp2);
    20743   if (arg2) memcpy(arg1->serial,arg2,64*sizeof(char));
    20744   else memset(arg1->serial,0,64*sizeof(char));
    20745   resultobj = SWIG_Py_Void();
    20746   return resultobj;
    20747 fail:
    20748   return NULL;
    20749 }
    20750 
    20751 
    20752 SWIGINTERN PyObject *_wrap_PTEID_TokenInfo_serial_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20753   PyObject *resultobj = 0;
    20754   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    20755   void *argp1 = 0 ;
    20756   int res1 = 0 ;
    20757   PyObject * obj0 = 0 ;
    20758   char *result = 0 ;
    20759  
    20760   if(!PyArg_UnpackTuple(args,(char *)"PTEID_TokenInfo_serial_get",1,1,&obj0)) SWIG_fail;
    20761   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, 0 |  0 );
    20762   if (!SWIG_IsOK(res1)) {
    20763     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_TokenInfo_serial_get" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    20764   }
    20765   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    20766   result = (char *)(char *) ((arg1)->serial);
    20767   {
    20768     size_t size = 64;
    20769    
    20770     while (size && (result[size - 1] == '\0')) --size;
    20771    
    20772     resultobj = SWIG_FromCharPtrAndSize(result, size);
    20773   }
    20774   return resultobj;
    20775 fail:
    20776   return NULL;
    20777 }
    20778 
    20779 
    20780 SWIGINTERN PyObject *_wrap_new_PTEID_TokenInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20781   PyObject *resultobj = 0;
    20782   eIDMW::PTEID_TokenInfo *result = 0 ;
    20783  
    20784   result = (eIDMW::PTEID_TokenInfo *)new eIDMW::PTEID_TokenInfo();
    20785   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_TokenInfo, SWIG_POINTER_NEW |  0 );
    20786   return resultobj;
    20787 fail:
    20788   return NULL;
    20789 }
    20790 
    20791 
    20792 SWIGINTERN PyObject *_wrap_delete_PTEID_TokenInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20793   PyObject *resultobj = 0;
    20794   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    20795   void *argp1 = 0 ;
    20796   int res1 = 0 ;
    20797   PyObject * obj0 = 0 ;
    20798  
    20799   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_TokenInfo",1,1,&obj0)) SWIG_fail;
    20800   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, SWIG_POINTER_DISOWN |  0 );
    20801   if (!SWIG_IsOK(res1)) {
    20802     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_TokenInfo" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    20803   }
    20804   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    20805   delete arg1;
    20806   resultobj = SWIG_Py_Void();
    20807   return resultobj;
    20808 fail:
    20809   return NULL;
    20810 }
    20811 
    20812 
    20813 SWIGINTERN PyObject *PTEID_TokenInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20814   PyObject *obj;
    20815   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    20816   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_TokenInfo, SWIG_NewClientData(obj));
    20817   return SWIG_Py_Void();
    20818 }
    20819 
    20820 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_modulus_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20821   PyObject *resultobj = 0;
    20822   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20823   unsigned char *arg2 = (unsigned char *) 0 ;
    20824   void *argp1 = 0 ;
    20825   int res1 = 0 ;
    20826   void *argp2 = 0 ;
    20827   int res2 = 0 ;
    20828   PyObject * obj0 = 0 ;
    20829   PyObject * obj1 = 0 ;
    20830  
    20831   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_modulus_set",2,2,&obj0,&obj1)) SWIG_fail;
    20832   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20833   if (!SWIG_IsOK(res1)) {
    20834     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_modulus_set" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20835   }
    20836   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20837   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
    20838   if (!SWIG_IsOK(res2)) {
    20839     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_RSAPublicKey_modulus_set" "', argument " "2"" of type '" "unsigned char *""'");
    20840   }
    20841   arg2 = reinterpret_cast< unsigned char * >(argp2);
    20842   if (arg1) (arg1)->modulus = arg2;
    20843   resultobj = SWIG_Py_Void();
    20844   return resultobj;
    20845 fail:
    20846   return NULL;
    20847 }
    20848 
    20849 
    20850 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_modulus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20851   PyObject *resultobj = 0;
    20852   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20853   void *argp1 = 0 ;
    20854   int res1 = 0 ;
    20855   PyObject * obj0 = 0 ;
    20856   unsigned char *result = 0 ;
    20857  
    20858   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_modulus_get",1,1,&obj0)) SWIG_fail;
    20859   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20860   if (!SWIG_IsOK(res1)) {
    20861     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_modulus_get" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20862   }
    20863   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20864   result = (unsigned char *) ((arg1)->modulus);
    20865   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    20866   return resultobj;
    20867 fail:
    20868   return NULL;
    20869 }
    20870 
    20871 
    20872 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_modulusLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20873   PyObject *resultobj = 0;
    20874   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20875   unsigned long arg2 ;
    20876   void *argp1 = 0 ;
    20877   int res1 = 0 ;
    20878   unsigned long val2 ;
    20879   int ecode2 = 0 ;
    20880   PyObject * obj0 = 0 ;
    20881   PyObject * obj1 = 0 ;
    20882  
    20883   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_modulusLength_set",2,2,&obj0,&obj1)) SWIG_fail;
    20884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20885   if (!SWIG_IsOK(res1)) {
    20886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_modulusLength_set" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20887   }
    20888   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20889   ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
    20890   if (!SWIG_IsOK(ecode2)) {
    20891     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_RSAPublicKey_modulusLength_set" "', argument " "2"" of type '" "unsigned long""'");
    20892   }
    20893   arg2 = static_cast< unsigned long >(val2);
    20894   if (arg1) (arg1)->modulusLength = arg2;
    20895   resultobj = SWIG_Py_Void();
    20896   return resultobj;
    20897 fail:
    20898   return NULL;
    20899 }
    20900 
    20901 
    20902 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_modulusLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20903   PyObject *resultobj = 0;
    20904   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20905   void *argp1 = 0 ;
    20906   int res1 = 0 ;
    20907   PyObject * obj0 = 0 ;
    20908   unsigned long result;
    20909  
    20910   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_modulusLength_get",1,1,&obj0)) SWIG_fail;
    20911   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20912   if (!SWIG_IsOK(res1)) {
    20913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_modulusLength_get" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20914   }
    20915   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20916   result = (unsigned long) ((arg1)->modulusLength);
    20917   resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
    20918   return resultobj;
    20919 fail:
    20920   return NULL;
    20921 }
    20922 
    20923 
    20924 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_exponent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20925   PyObject *resultobj = 0;
    20926   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20927   unsigned char *arg2 = (unsigned char *) 0 ;
    20928   void *argp1 = 0 ;
    20929   int res1 = 0 ;
    20930   void *argp2 = 0 ;
    20931   int res2 = 0 ;
    20932   PyObject * obj0 = 0 ;
    20933   PyObject * obj1 = 0 ;
    20934  
    20935   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_exponent_set",2,2,&obj0,&obj1)) SWIG_fail;
    20936   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20937   if (!SWIG_IsOK(res1)) {
    20938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_exponent_set" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20939   }
    20940   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20941   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
    20942   if (!SWIG_IsOK(res2)) {
    20943     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_RSAPublicKey_exponent_set" "', argument " "2"" of type '" "unsigned char *""'");
    20944   }
    20945   arg2 = reinterpret_cast< unsigned char * >(argp2);
    20946   if (arg1) (arg1)->exponent = arg2;
    20947   resultobj = SWIG_Py_Void();
    20948   return resultobj;
    20949 fail:
    20950   return NULL;
    20951 }
    20952 
    20953 
    20954 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_exponent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20955   PyObject *resultobj = 0;
    20956   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20957   void *argp1 = 0 ;
    20958   int res1 = 0 ;
    20959   PyObject * obj0 = 0 ;
    20960   unsigned char *result = 0 ;
    20961  
    20962   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_exponent_get",1,1,&obj0)) SWIG_fail;
    20963   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20964   if (!SWIG_IsOK(res1)) {
    20965     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_exponent_get" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20966   }
    20967   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20968   result = (unsigned char *) ((arg1)->exponent);
    20969   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    20970   return resultobj;
    20971 fail:
    20972   return NULL;
    20973 }
    20974 
    20975 
    20976 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_exponentLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    20977   PyObject *resultobj = 0;
    20978   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    20979   unsigned char arg2 ;
    20980   void *argp1 = 0 ;
    20981   int res1 = 0 ;
    20982   unsigned char val2 ;
    20983   int ecode2 = 0 ;
    20984   PyObject * obj0 = 0 ;
    20985   PyObject * obj1 = 0 ;
    20986  
    20987   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_exponentLength_set",2,2,&obj0,&obj1)) SWIG_fail;
    20988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    20989   if (!SWIG_IsOK(res1)) {
    20990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_exponentLength_set" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    20991   }
    20992   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    20993   ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
    20994   if (!SWIG_IsOK(ecode2)) {
    20995     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_RSAPublicKey_exponentLength_set" "', argument " "2"" of type '" "unsigned char""'");
    20996   }
    20997   arg2 = static_cast< unsigned char >(val2);
    20998   if (arg1) (arg1)->exponentLength = arg2;
    20999   resultobj = SWIG_Py_Void();
    21000   return resultobj;
    21001 fail:
    21002   return NULL;
    21003 }
    21004 
    21005 
    21006 SWIGINTERN PyObject *_wrap_PTEID_RSAPublicKey_exponentLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21007   PyObject *resultobj = 0;
    21008   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    21009   void *argp1 = 0 ;
    21010   int res1 = 0 ;
    21011   PyObject * obj0 = 0 ;
    21012   unsigned char result;
    21013  
    21014   if(!PyArg_UnpackTuple(args,(char *)"PTEID_RSAPublicKey_exponentLength_get",1,1,&obj0)) SWIG_fail;
    21015   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    21016   if (!SWIG_IsOK(res1)) {
    21017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_RSAPublicKey_exponentLength_get" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    21018   }
    21019   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    21020   result = (unsigned char) ((arg1)->exponentLength);
    21021   resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
    21022   return resultobj;
    21023 fail:
    21024   return NULL;
    21025 }
    21026 
    21027 
    21028 SWIGINTERN PyObject *_wrap_new_PTEID_RSAPublicKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21029   PyObject *resultobj = 0;
    21030   eIDMW::PTEID_RSAPublicKey *result = 0 ;
    21031  
    21032   result = (eIDMW::PTEID_RSAPublicKey *)new eIDMW::PTEID_RSAPublicKey();
    21033   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, SWIG_POINTER_NEW |  0 );
    21034   return resultobj;
    21035 fail:
    21036   return NULL;
    21037 }
    21038 
    21039 
    21040 SWIGINTERN PyObject *_wrap_delete_PTEID_RSAPublicKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21041   PyObject *resultobj = 0;
    21042   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    21043   void *argp1 = 0 ;
    21044   int res1 = 0 ;
    21045   PyObject * obj0 = 0 ;
    21046  
    21047   if(!PyArg_UnpackTuple(args,(char *)"delete_PTEID_RSAPublicKey",1,1,&obj0)) SWIG_fail;
    21048   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, SWIG_POINTER_DISOWN |  0 );
    21049   if (!SWIG_IsOK(res1)) {
    21050     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTEID_RSAPublicKey" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    21051   }
    21052   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    21053   delete arg1;
    21054   resultobj = SWIG_Py_Void();
    21055   return resultobj;
    21056 fail:
    21057   return NULL;
    21058 }
    21059 
    21060 
    21061 SWIGINTERN PyObject *PTEID_RSAPublicKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21062   PyObject *obj;
    21063   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    21064   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, SWIG_NewClientData(obj));
    21065   return SWIG_Py_Void();
    21066 }
    21067 
    21068 SWIGINTERN PyObject *_wrap_tProxyInfo_csProxy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21069   PyObject *resultobj = 0;
    21070   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21071   char *arg2 = (char *) 0 ;
    21072   void *argp1 = 0 ;
    21073   int res1 = 0 ;
    21074   int res2 ;
    21075   char *buf2 = 0 ;
    21076   int alloc2 = 0 ;
    21077   PyObject * obj0 = 0 ;
    21078   PyObject * obj1 = 0 ;
    21079  
    21080   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csProxy_set",2,2,&obj0,&obj1)) SWIG_fail;
    21081   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21082   if (!SWIG_IsOK(res1)) {
    21083     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csProxy_set" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21084   }
    21085   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21086   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21087   if (!SWIG_IsOK(res2)) {
    21088     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tProxyInfo_csProxy_set" "', argument " "2"" of type '" "char const *""'");
    21089   }
    21090   arg2 = reinterpret_cast< char * >(buf2);
    21091   if (arg2) {
    21092     size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    21093     arg1->csProxy = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
    21094   } else {
    21095     arg1->csProxy = 0;
    21096   }
    21097   resultobj = SWIG_Py_Void();
    21098   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21099   return resultobj;
    21100 fail:
    21101   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21102   return NULL;
    21103 }
    21104 
    21105 
    21106 SWIGINTERN PyObject *_wrap_tProxyInfo_csProxy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21107   PyObject *resultobj = 0;
    21108   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21109   void *argp1 = 0 ;
    21110   int res1 = 0 ;
    21111   PyObject * obj0 = 0 ;
    21112   char *result = 0 ;
    21113  
    21114   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csProxy_get",1,1,&obj0)) SWIG_fail;
    21115   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21116   if (!SWIG_IsOK(res1)) {
    21117     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csProxy_get" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21118   }
    21119   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21120   result = (char *) ((arg1)->csProxy);
    21121   resultobj = SWIG_FromCharPtr((const char *)result);
    21122   return resultobj;
    21123 fail:
    21124   return NULL;
    21125 }
    21126 
    21127 
    21128 SWIGINTERN PyObject *_wrap_tProxyInfo_uiPort_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21129   PyObject *resultobj = 0;
    21130   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21131   unsigned int arg2 ;
    21132   void *argp1 = 0 ;
    21133   int res1 = 0 ;
    21134   unsigned int val2 ;
    21135   int ecode2 = 0 ;
    21136   PyObject * obj0 = 0 ;
    21137   PyObject * obj1 = 0 ;
    21138  
    21139   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_uiPort_set",2,2,&obj0,&obj1)) SWIG_fail;
    21140   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21141   if (!SWIG_IsOK(res1)) {
    21142     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_uiPort_set" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21143   }
    21144   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21145   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    21146   if (!SWIG_IsOK(ecode2)) {
    21147     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tProxyInfo_uiPort_set" "', argument " "2"" of type '" "unsigned int""'");
    21148   }
    21149   arg2 = static_cast< unsigned int >(val2);
    21150   if (arg1) (arg1)->uiPort = arg2;
    21151   resultobj = SWIG_Py_Void();
    21152   return resultobj;
    21153 fail:
    21154   return NULL;
    21155 }
    21156 
    21157 
    21158 SWIGINTERN PyObject *_wrap_tProxyInfo_uiPort_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21159   PyObject *resultobj = 0;
    21160   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21161   void *argp1 = 0 ;
    21162   int res1 = 0 ;
    21163   PyObject * obj0 = 0 ;
    21164   unsigned int result;
    21165  
    21166   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_uiPort_get",1,1,&obj0)) SWIG_fail;
    21167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21168   if (!SWIG_IsOK(res1)) {
    21169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_uiPort_get" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21170   }
    21171   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21172   result = (unsigned int) ((arg1)->uiPort);
    21173   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    21174   return resultobj;
    21175 fail:
    21176   return NULL;
    21177 }
    21178 
    21179 
    21180 SWIGINTERN PyObject *_wrap_tProxyInfo_csUserName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21181   PyObject *resultobj = 0;
    21182   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21183   char *arg2 = (char *) 0 ;
    21184   void *argp1 = 0 ;
    21185   int res1 = 0 ;
    21186   int res2 ;
    21187   char *buf2 = 0 ;
    21188   int alloc2 = 0 ;
    21189   PyObject * obj0 = 0 ;
    21190   PyObject * obj1 = 0 ;
    21191  
    21192   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csUserName_set",2,2,&obj0,&obj1)) SWIG_fail;
    21193   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21194   if (!SWIG_IsOK(res1)) {
    21195     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csUserName_set" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21196   }
    21197   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21198   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21199   if (!SWIG_IsOK(res2)) {
    21200     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tProxyInfo_csUserName_set" "', argument " "2"" of type '" "char const *""'");
    21201   }
    21202   arg2 = reinterpret_cast< char * >(buf2);
    21203   if (arg2) {
    21204     size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    21205     arg1->csUserName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
    21206   } else {
    21207     arg1->csUserName = 0;
    21208   }
    21209   resultobj = SWIG_Py_Void();
    21210   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21211   return resultobj;
    21212 fail:
    21213   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21214   return NULL;
    21215 }
    21216 
    21217 
    21218 SWIGINTERN PyObject *_wrap_tProxyInfo_csUserName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21219   PyObject *resultobj = 0;
    21220   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21221   void *argp1 = 0 ;
    21222   int res1 = 0 ;
    21223   PyObject * obj0 = 0 ;
    21224   char *result = 0 ;
    21225  
    21226   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csUserName_get",1,1,&obj0)) SWIG_fail;
    21227   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21228   if (!SWIG_IsOK(res1)) {
    21229     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csUserName_get" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21230   }
    21231   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21232   result = (char *) ((arg1)->csUserName);
    21233   resultobj = SWIG_FromCharPtr((const char *)result);
    21234   return resultobj;
    21235 fail:
    21236   return NULL;
    21237 }
    21238 
    21239 
    21240 SWIGINTERN PyObject *_wrap_tProxyInfo_csPassword_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21241   PyObject *resultobj = 0;
    21242   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21243   char *arg2 = (char *) 0 ;
    21244   void *argp1 = 0 ;
    21245   int res1 = 0 ;
    21246   int res2 ;
    21247   char *buf2 = 0 ;
    21248   int alloc2 = 0 ;
    21249   PyObject * obj0 = 0 ;
    21250   PyObject * obj1 = 0 ;
    21251  
    21252   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csPassword_set",2,2,&obj0,&obj1)) SWIG_fail;
    21253   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21254   if (!SWIG_IsOK(res1)) {
    21255     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csPassword_set" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21256   }
    21257   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21258   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21259   if (!SWIG_IsOK(res2)) {
    21260     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tProxyInfo_csPassword_set" "', argument " "2"" of type '" "char const *""'");
    21261   }
    21262   arg2 = reinterpret_cast< char * >(buf2);
    21263   if (arg2) {
    21264     size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    21265     arg1->csPassword = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
    21266   } else {
    21267     arg1->csPassword = 0;
    21268   }
    21269   resultobj = SWIG_Py_Void();
    21270   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21271   return resultobj;
    21272 fail:
    21273   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21274   return NULL;
    21275 }
    21276 
    21277 
    21278 SWIGINTERN PyObject *_wrap_tProxyInfo_csPassword_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21279   PyObject *resultobj = 0;
    21280   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21281   void *argp1 = 0 ;
    21282   int res1 = 0 ;
    21283   PyObject * obj0 = 0 ;
    21284   char *result = 0 ;
    21285  
    21286   if(!PyArg_UnpackTuple(args,(char *)"tProxyInfo_csPassword_get",1,1,&obj0)) SWIG_fail;
    21287   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    21288   if (!SWIG_IsOK(res1)) {
    21289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tProxyInfo_csPassword_get" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21290   }
    21291   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21292   result = (char *) ((arg1)->csPassword);
    21293   resultobj = SWIG_FromCharPtr((const char *)result);
    21294   return resultobj;
    21295 fail:
    21296   return NULL;
    21297 }
    21298 
    21299 
    21300 SWIGINTERN PyObject *_wrap_new_tProxyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21301   PyObject *resultobj = 0;
    21302   eIDMW::tProxyInfo *result = 0 ;
    21303  
    21304   result = (eIDMW::tProxyInfo *)new eIDMW::tProxyInfo();
    21305   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eIDMW__tProxyInfo, SWIG_POINTER_NEW |  0 );
    21306   return resultobj;
    21307 fail:
    21308   return NULL;
    21309 }
    21310 
    21311 
    21312 SWIGINTERN PyObject *_wrap_delete_tProxyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21313   PyObject *resultobj = 0;
    21314   eIDMW::tProxyInfo *arg1 = (eIDMW::tProxyInfo *) 0 ;
    21315   void *argp1 = 0 ;
    21316   int res1 = 0 ;
    21317   PyObject * obj0 = 0 ;
    21318  
    21319   if(!PyArg_UnpackTuple(args,(char *)"delete_tProxyInfo",1,1,&obj0)) SWIG_fail;
    21320   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__tProxyInfo, SWIG_POINTER_DISOWN |  0 );
    21321   if (!SWIG_IsOK(res1)) {
    21322     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_tProxyInfo" "', argument " "1"" of type '" "eIDMW::tProxyInfo *""'");
    21323   }
    21324   arg1 = reinterpret_cast< eIDMW::tProxyInfo * >(argp1);
    21325   delete arg1;
    21326   resultobj = SWIG_Py_Void();
    21327   return resultobj;
    21328 fail:
    21329   return NULL;
    21330 }
    21331 
    21332 
    21333 SWIGINTERN PyObject *tProxyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21334   PyObject *obj;
    21335   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    21336   SWIG_TypeNewClientData(SWIGTYPE_p_eIDMW__tProxyInfo, SWIG_NewClientData(obj));
    21337   return SWIG_Py_Void();
    21338 }
    21339 
    21340 SWIGINTERN PyObject *_wrap_PTEID_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21341   PyObject *resultobj = 0;
    21342   char *arg1 = (char *) 0 ;
    21343   int res1 ;
    21344   char *buf1 = 0 ;
    21345   int alloc1 = 0 ;
    21346   PyObject * obj0 = 0 ;
    21347   long result;
    21348  
    21349   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Init",1,1,&obj0)) SWIG_fail;
    21350   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    21351   if (!SWIG_IsOK(res1)) {
    21352     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Init" "', argument " "1"" of type '" "char *""'");
    21353   }
    21354   arg1 = reinterpret_cast< char * >(buf1);
    21355   result = (long)eIDMW::PTEID_Init(arg1);
    21356   resultobj = SWIG_From_long(static_cast< long >(result));
    21357   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    21358   return resultobj;
    21359 fail:
    21360   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    21361   return NULL;
    21362 }
    21363 
    21364 
    21365 SWIGINTERN PyObject *_wrap_PTEID_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21366   PyObject *resultobj = 0;
    21367   unsigned long arg1 ;
    21368   unsigned long val1 ;
    21369   int ecode1 = 0 ;
    21370   PyObject * obj0 = 0 ;
    21371   long result;
    21372  
    21373   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Exit",1,1,&obj0)) SWIG_fail;
    21374   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
    21375   if (!SWIG_IsOK(ecode1)) {
    21376     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_Exit" "', argument " "1"" of type '" "unsigned long""'");
    21377   }
    21378   arg1 = static_cast< unsigned long >(val1);
    21379   result = (long)eIDMW::PTEID_Exit(arg1);
    21380   resultobj = SWIG_From_long(static_cast< long >(result));
    21381   return resultobj;
    21382 fail:
    21383   return NULL;
    21384 }
    21385 
    21386 
    21387 SWIGINTERN PyObject *_wrap_PTEID_GetCardType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21388   PyObject *resultobj = 0;
    21389   eIDMW::tCompCardType result;
    21390  
    21391   result = (eIDMW::tCompCardType)eIDMW::PTEID_GetCardType();
    21392   resultobj = SWIG_From_int(static_cast< int >(result));
    21393   return resultobj;
    21394 fail:
    21395   return NULL;
    21396 }
    21397 
    21398 
    21399 SWIGINTERN PyObject *_wrap_PTEID_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21400   PyObject *resultobj = 0;
    21401   eIDMW::PTEID_ID *arg1 = (eIDMW::PTEID_ID *) 0 ;
    21402   void *argp1 = 0 ;
    21403   int res1 = 0 ;
    21404   PyObject * obj0 = 0 ;
    21405   long result;
    21406  
    21407   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetID",1,1,&obj0)) SWIG_fail;
    21408   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ID, 0 |  0 );
    21409   if (!SWIG_IsOK(res1)) {
    21410     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetID" "', argument " "1"" of type '" "eIDMW::PTEID_ID *""'");
    21411   }
    21412   arg1 = reinterpret_cast< eIDMW::PTEID_ID * >(argp1);
    21413   result = (long)eIDMW::PTEID_GetID(arg1);
    21414   resultobj = SWIG_From_long(static_cast< long >(result));
    21415   return resultobj;
    21416 fail:
    21417   return NULL;
    21418 }
    21419 
    21420 
    21421 SWIGINTERN PyObject *_wrap_PTEID_GetAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21422   PyObject *resultobj = 0;
    21423   eIDMW::PTEID_ADDR *arg1 = (eIDMW::PTEID_ADDR *) 0 ;
    21424   void *argp1 = 0 ;
    21425   int res1 = 0 ;
    21426   PyObject * obj0 = 0 ;
    21427   long result;
    21428  
    21429   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetAddr",1,1,&obj0)) SWIG_fail;
    21430   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_ADDR, 0 |  0 );
    21431   if (!SWIG_IsOK(res1)) {
    21432     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetAddr" "', argument " "1"" of type '" "eIDMW::PTEID_ADDR *""'");
    21433   }
    21434   arg1 = reinterpret_cast< eIDMW::PTEID_ADDR * >(argp1);
    21435   result = (long)eIDMW::PTEID_GetAddr(arg1);
    21436   resultobj = SWIG_From_long(static_cast< long >(result));
    21437   return resultobj;
    21438 fail:
    21439   return NULL;
    21440 }
    21441 
    21442 
    21443 SWIGINTERN PyObject *_wrap_PTEID_GetPic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21444   PyObject *resultobj = 0;
    21445   eIDMW::PTEID_PIC *arg1 = (eIDMW::PTEID_PIC *) 0 ;
    21446   void *argp1 = 0 ;
    21447   int res1 = 0 ;
    21448   PyObject * obj0 = 0 ;
    21449   long result;
    21450  
    21451   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetPic",1,1,&obj0)) SWIG_fail;
    21452   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_PIC, 0 |  0 );
    21453   if (!SWIG_IsOK(res1)) {
    21454     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetPic" "', argument " "1"" of type '" "eIDMW::PTEID_PIC *""'");
    21455   }
    21456   arg1 = reinterpret_cast< eIDMW::PTEID_PIC * >(argp1);
    21457   result = (long)eIDMW::PTEID_GetPic(arg1);
    21458   resultobj = SWIG_From_long(static_cast< long >(result));
    21459   return resultobj;
    21460 fail:
    21461   return NULL;
    21462 }
    21463 
    21464 
    21465 SWIGINTERN PyObject *_wrap_PTEID_GetCertificates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21466   PyObject *resultobj = 0;
    21467   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    21468   void *argp1 = 0 ;
    21469   int res1 = 0 ;
    21470   PyObject * obj0 = 0 ;
    21471   long result;
    21472  
    21473   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetCertificates",1,1,&obj0)) SWIG_fail;
    21474   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    21475   if (!SWIG_IsOK(res1)) {
    21476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetCertificates" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    21477   }
    21478   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    21479   result = (long)eIDMW::PTEID_GetCertificates(arg1);
    21480   resultobj = SWIG_From_long(static_cast< long >(result));
    21481   return resultobj;
    21482 fail:
    21483   return NULL;
    21484 }
    21485 
    21486 
    21487 SWIGINTERN PyObject *_wrap_PTEID_VerifyPIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21488   PyObject *resultobj = 0;
    21489   unsigned char arg1 ;
    21490   char *arg2 = (char *) 0 ;
    21491   long *arg3 = (long *) 0 ;
    21492   unsigned char val1 ;
    21493   int ecode1 = 0 ;
    21494   int res2 ;
    21495   char *buf2 = 0 ;
    21496   int alloc2 = 0 ;
    21497   void *argp3 = 0 ;
    21498   int res3 = 0 ;
    21499   PyObject * obj0 = 0 ;
    21500   PyObject * obj1 = 0 ;
    21501   PyObject * obj2 = 0 ;
    21502   long result;
    21503  
    21504   if(!PyArg_UnpackTuple(args,(char *)"PTEID_VerifyPIN",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
    21505   ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
    21506   if (!SWIG_IsOK(ecode1)) {
    21507     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_VerifyPIN" "', argument " "1"" of type '" "unsigned char""'");
    21508   }
    21509   arg1 = static_cast< unsigned char >(val1);
    21510   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21511   if (!SWIG_IsOK(res2)) {
    21512     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_VerifyPIN" "', argument " "2"" of type '" "char *""'");
    21513   }
    21514   arg2 = reinterpret_cast< char * >(buf2);
    21515   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 |  0 );
    21516   if (!SWIG_IsOK(res3)) {
    21517     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_VerifyPIN" "', argument " "3"" of type '" "long *""'");
    21518   }
    21519   arg3 = reinterpret_cast< long * >(argp3);
    21520   result = (long)eIDMW::PTEID_VerifyPIN(arg1,arg2,arg3);
    21521   resultobj = SWIG_From_long(static_cast< long >(result));
    21522   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21523   return resultobj;
    21524 fail:
    21525   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21526   return NULL;
    21527 }
    21528 
    21529 
    21530 SWIGINTERN PyObject *_wrap_PTEID_VerifyPIN_No_Alert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21531   PyObject *resultobj = 0;
    21532   unsigned char arg1 ;
    21533   char *arg2 = (char *) 0 ;
    21534   long *arg3 = (long *) 0 ;
    21535   unsigned char val1 ;
    21536   int ecode1 = 0 ;
    21537   int res2 ;
    21538   char *buf2 = 0 ;
    21539   int alloc2 = 0 ;
    21540   void *argp3 = 0 ;
    21541   int res3 = 0 ;
    21542   PyObject * obj0 = 0 ;
    21543   PyObject * obj1 = 0 ;
    21544   PyObject * obj2 = 0 ;
    21545   long result;
    21546  
    21547   if(!PyArg_UnpackTuple(args,(char *)"PTEID_VerifyPIN_No_Alert",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
    21548   ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
    21549   if (!SWIG_IsOK(ecode1)) {
    21550     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_VerifyPIN_No_Alert" "', argument " "1"" of type '" "unsigned char""'");
    21551   }
    21552   arg1 = static_cast< unsigned char >(val1);
    21553   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21554   if (!SWIG_IsOK(res2)) {
    21555     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_VerifyPIN_No_Alert" "', argument " "2"" of type '" "char *""'");
    21556   }
    21557   arg2 = reinterpret_cast< char * >(buf2);
    21558   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 |  0 );
    21559   if (!SWIG_IsOK(res3)) {
    21560     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_VerifyPIN_No_Alert" "', argument " "3"" of type '" "long *""'");
    21561   }
    21562   arg3 = reinterpret_cast< long * >(argp3);
    21563   result = (long)eIDMW::PTEID_VerifyPIN_No_Alert(arg1,arg2,arg3);
    21564   resultobj = SWIG_From_long(static_cast< long >(result));
    21565   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21566   return resultobj;
    21567 fail:
    21568   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21569   return NULL;
    21570 }
    21571 
    21572 
    21573 SWIGINTERN PyObject *_wrap_PTEID_ChangePIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21574   PyObject *resultobj = 0;
    21575   unsigned char arg1 ;
    21576   char *arg2 = (char *) 0 ;
    21577   char *arg3 = (char *) 0 ;
    21578   long *arg4 = (long *) 0 ;
    21579   unsigned char val1 ;
    21580   int ecode1 = 0 ;
    21581   int res2 ;
    21582   char *buf2 = 0 ;
    21583   int alloc2 = 0 ;
    21584   int res3 ;
    21585   char *buf3 = 0 ;
    21586   int alloc3 = 0 ;
    21587   void *argp4 = 0 ;
    21588   int res4 = 0 ;
    21589   PyObject * obj0 = 0 ;
    21590   PyObject * obj1 = 0 ;
    21591   PyObject * obj2 = 0 ;
    21592   PyObject * obj3 = 0 ;
    21593   long result;
    21594  
    21595   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ChangePIN",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
    21596   ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
    21597   if (!SWIG_IsOK(ecode1)) {
    21598     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_ChangePIN" "', argument " "1"" of type '" "unsigned char""'");
    21599   }
    21600   arg1 = static_cast< unsigned char >(val1);
    21601   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21602   if (!SWIG_IsOK(res2)) {
    21603     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ChangePIN" "', argument " "2"" of type '" "char *""'");
    21604   }
    21605   arg2 = reinterpret_cast< char * >(buf2);
    21606   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    21607   if (!SWIG_IsOK(res3)) {
    21608     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_ChangePIN" "', argument " "3"" of type '" "char *""'");
    21609   }
    21610   arg3 = reinterpret_cast< char * >(buf3);
    21611   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_long, 0 |  0 );
    21612   if (!SWIG_IsOK(res4)) {
    21613     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_ChangePIN" "', argument " "4"" of type '" "long *""'");
    21614   }
    21615   arg4 = reinterpret_cast< long * >(argp4);
    21616   result = (long)eIDMW::PTEID_ChangePIN(arg1,arg2,arg3,arg4);
    21617   resultobj = SWIG_From_long(static_cast< long >(result));
    21618   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21619   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21620   return resultobj;
    21621 fail:
    21622   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21623   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21624   return NULL;
    21625 }
    21626 
    21627 
    21628 SWIGINTERN PyObject *_wrap_PTEID_GetPINs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21629   PyObject *resultobj = 0;
    21630   eIDMW::PTEIDPins *arg1 = (eIDMW::PTEIDPins *) 0 ;
    21631   void *argp1 = 0 ;
    21632   int res1 = 0 ;
    21633   PyObject * obj0 = 0 ;
    21634   long result;
    21635  
    21636   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetPINs",1,1,&obj0)) SWIG_fail;
    21637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEIDPins, 0 |  0 );
    21638   if (!SWIG_IsOK(res1)) {
    21639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetPINs" "', argument " "1"" of type '" "eIDMW::PTEIDPins *""'");
    21640   }
    21641   arg1 = reinterpret_cast< eIDMW::PTEIDPins * >(argp1);
    21642   result = (long)eIDMW::PTEID_GetPINs(arg1);
    21643   resultobj = SWIG_From_long(static_cast< long >(result));
    21644   return resultobj;
    21645 fail:
    21646   return NULL;
    21647 }
    21648 
    21649 
    21650 SWIGINTERN PyObject *_wrap_PTEID_GetTokenInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21651   PyObject *resultobj = 0;
    21652   eIDMW::PTEID_TokenInfo *arg1 = (eIDMW::PTEID_TokenInfo *) 0 ;
    21653   void *argp1 = 0 ;
    21654   int res1 = 0 ;
    21655   PyObject * obj0 = 0 ;
    21656   long result;
    21657  
    21658   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetTokenInfo",1,1,&obj0)) SWIG_fail;
    21659   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_TokenInfo, 0 |  0 );
    21660   if (!SWIG_IsOK(res1)) {
    21661     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetTokenInfo" "', argument " "1"" of type '" "eIDMW::PTEID_TokenInfo *""'");
    21662   }
    21663   arg1 = reinterpret_cast< eIDMW::PTEID_TokenInfo * >(argp1);
    21664   result = (long)eIDMW::PTEID_GetTokenInfo(arg1);
    21665   resultobj = SWIG_From_long(static_cast< long >(result));
    21666   return resultobj;
    21667 fail:
    21668   return NULL;
    21669 }
    21670 
    21671 
    21672 SWIGINTERN PyObject *_wrap_PTEID_ReadSOD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21673   PyObject *resultobj = 0;
    21674   unsigned char *arg1 = (unsigned char *) 0 ;
    21675   unsigned long *arg2 = (unsigned long *) 0 ;
    21676   void *argp1 = 0 ;
    21677   int res1 = 0 ;
    21678   void *argp2 = 0 ;
    21679   int res2 = 0 ;
    21680   PyObject * obj0 = 0 ;
    21681   PyObject * obj1 = 0 ;
    21682   long result;
    21683  
    21684   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ReadSOD",2,2,&obj0,&obj1)) SWIG_fail;
    21685   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21686   if (!SWIG_IsOK(res1)) {
    21687     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ReadSOD" "', argument " "1"" of type '" "unsigned char *""'");
    21688   }
    21689   arg1 = reinterpret_cast< unsigned char * >(argp1);
    21690   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
    21691   if (!SWIG_IsOK(res2)) {
    21692     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_ReadSOD" "', argument " "2"" of type '" "unsigned long *""'");
    21693   }
    21694   arg2 = reinterpret_cast< unsigned long * >(argp2);
    21695   result = (long)eIDMW::PTEID_ReadSOD(arg1,arg2);
    21696   resultobj = SWIG_From_long(static_cast< long >(result));
    21697   return resultobj;
    21698 fail:
    21699   return NULL;
    21700 }
    21701 
    21702 
    21703 SWIGINTERN PyObject *_wrap_PTEID_UnblockPIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21704   PyObject *resultobj = 0;
    21705   unsigned char arg1 ;
    21706   char *arg2 = (char *) 0 ;
    21707   char *arg3 = (char *) 0 ;
    21708   long *arg4 = (long *) 0 ;
    21709   unsigned char val1 ;
    21710   int ecode1 = 0 ;
    21711   int res2 ;
    21712   char *buf2 = 0 ;
    21713   int alloc2 = 0 ;
    21714   int res3 ;
    21715   char *buf3 = 0 ;
    21716   int alloc3 = 0 ;
    21717   void *argp4 = 0 ;
    21718   int res4 = 0 ;
    21719   PyObject * obj0 = 0 ;
    21720   PyObject * obj1 = 0 ;
    21721   PyObject * obj2 = 0 ;
    21722   PyObject * obj3 = 0 ;
    21723   long result;
    21724  
    21725   if(!PyArg_UnpackTuple(args,(char *)"PTEID_UnblockPIN",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
    21726   ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
    21727   if (!SWIG_IsOK(ecode1)) {
    21728     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_UnblockPIN" "', argument " "1"" of type '" "unsigned char""'");
    21729   }
    21730   arg1 = static_cast< unsigned char >(val1);
    21731   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21732   if (!SWIG_IsOK(res2)) {
    21733     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_UnblockPIN" "', argument " "2"" of type '" "char *""'");
    21734   }
    21735   arg2 = reinterpret_cast< char * >(buf2);
    21736   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    21737   if (!SWIG_IsOK(res3)) {
    21738     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_UnblockPIN" "', argument " "3"" of type '" "char *""'");
    21739   }
    21740   arg3 = reinterpret_cast< char * >(buf3);
    21741   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_long, 0 |  0 );
    21742   if (!SWIG_IsOK(res4)) {
    21743     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_UnblockPIN" "', argument " "4"" of type '" "long *""'");
    21744   }
    21745   arg4 = reinterpret_cast< long * >(argp4);
    21746   result = (long)eIDMW::PTEID_UnblockPIN(arg1,arg2,arg3,arg4);
    21747   resultobj = SWIG_From_long(static_cast< long >(result));
    21748   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21749   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21750   return resultobj;
    21751 fail:
    21752   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21753   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21754   return NULL;
    21755 }
    21756 
    21757 
    21758 SWIGINTERN PyObject *_wrap_PTEID_UnblockPIN_Ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21759   PyObject *resultobj = 0;
    21760   unsigned char arg1 ;
    21761   char *arg2 = (char *) 0 ;
    21762   char *arg3 = (char *) 0 ;
    21763   long *arg4 = (long *) 0 ;
    21764   unsigned long arg5 ;
    21765   unsigned char val1 ;
    21766   int ecode1 = 0 ;
    21767   int res2 ;
    21768   char *buf2 = 0 ;
    21769   int alloc2 = 0 ;
    21770   int res3 ;
    21771   char *buf3 = 0 ;
    21772   int alloc3 = 0 ;
    21773   void *argp4 = 0 ;
    21774   int res4 = 0 ;
    21775   unsigned long val5 ;
    21776   int ecode5 = 0 ;
    21777   PyObject * obj0 = 0 ;
    21778   PyObject * obj1 = 0 ;
    21779   PyObject * obj2 = 0 ;
    21780   PyObject * obj3 = 0 ;
    21781   PyObject * obj4 = 0 ;
    21782   long result;
    21783  
    21784   if(!PyArg_UnpackTuple(args,(char *)"PTEID_UnblockPIN_Ext",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
    21785   ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
    21786   if (!SWIG_IsOK(ecode1)) {
    21787     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_UnblockPIN_Ext" "', argument " "1"" of type '" "unsigned char""'");
    21788   }
    21789   arg1 = static_cast< unsigned char >(val1);
    21790   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    21791   if (!SWIG_IsOK(res2)) {
    21792     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_UnblockPIN_Ext" "', argument " "2"" of type '" "char *""'");
    21793   }
    21794   arg2 = reinterpret_cast< char * >(buf2);
    21795   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    21796   if (!SWIG_IsOK(res3)) {
    21797     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_UnblockPIN_Ext" "', argument " "3"" of type '" "char *""'");
    21798   }
    21799   arg3 = reinterpret_cast< char * >(buf3);
    21800   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_long, 0 |  0 );
    21801   if (!SWIG_IsOK(res4)) {
    21802     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_UnblockPIN_Ext" "', argument " "4"" of type '" "long *""'");
    21803   }
    21804   arg4 = reinterpret_cast< long * >(argp4);
    21805   ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
    21806   if (!SWIG_IsOK(ecode5)) {
    21807     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PTEID_UnblockPIN_Ext" "', argument " "5"" of type '" "unsigned long""'");
    21808   }
    21809   arg5 = static_cast< unsigned long >(val5);
    21810   result = (long)eIDMW::PTEID_UnblockPIN_Ext(arg1,arg2,arg3,arg4,arg5);
    21811   resultobj = SWIG_From_long(static_cast< long >(result));
    21812   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21813   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21814   return resultobj;
    21815 fail:
    21816   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    21817   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    21818   return NULL;
    21819 }
    21820 
    21821 
    21822 SWIGINTERN PyObject *_wrap_PTEID_SelectADF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21823   PyObject *resultobj = 0;
    21824   unsigned char *arg1 = (unsigned char *) 0 ;
    21825   long arg2 ;
    21826   void *argp1 = 0 ;
    21827   int res1 = 0 ;
    21828   long val2 ;
    21829   int ecode2 = 0 ;
    21830   PyObject * obj0 = 0 ;
    21831   PyObject * obj1 = 0 ;
    21832   long result;
    21833  
    21834   if(!PyArg_UnpackTuple(args,(char *)"PTEID_SelectADF",2,2,&obj0,&obj1)) SWIG_fail;
    21835   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21836   if (!SWIG_IsOK(res1)) {
    21837     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_SelectADF" "', argument " "1"" of type '" "unsigned char *""'");
    21838   }
    21839   arg1 = reinterpret_cast< unsigned char * >(argp1);
    21840   ecode2 = SWIG_AsVal_long(obj1, &val2);
    21841   if (!SWIG_IsOK(ecode2)) {
    21842     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_SelectADF" "', argument " "2"" of type '" "long""'");
    21843   }
    21844   arg2 = static_cast< long >(val2);
    21845   result = (long)eIDMW::PTEID_SelectADF(arg1,arg2);
    21846   resultobj = SWIG_From_long(static_cast< long >(result));
    21847   return resultobj;
    21848 fail:
    21849   return NULL;
    21850 }
    21851 
    21852 
    21853 SWIGINTERN PyObject *_wrap_PTEID_ReadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21854   PyObject *resultobj = 0;
    21855   unsigned char *arg1 = (unsigned char *) 0 ;
    21856   int arg2 ;
    21857   unsigned char *arg3 = (unsigned char *) 0 ;
    21858   unsigned long *arg4 = (unsigned long *) 0 ;
    21859   unsigned char arg5 ;
    21860   void *argp1 = 0 ;
    21861   int res1 = 0 ;
    21862   int val2 ;
    21863   int ecode2 = 0 ;
    21864   void *argp3 = 0 ;
    21865   int res3 = 0 ;
    21866   void *argp4 = 0 ;
    21867   int res4 = 0 ;
    21868   unsigned char val5 ;
    21869   int ecode5 = 0 ;
    21870   PyObject * obj0 = 0 ;
    21871   PyObject * obj1 = 0 ;
    21872   PyObject * obj2 = 0 ;
    21873   PyObject * obj3 = 0 ;
    21874   PyObject * obj4 = 0 ;
    21875   long result;
    21876  
    21877   if(!PyArg_UnpackTuple(args,(char *)"PTEID_ReadFile",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
    21878   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21879   if (!SWIG_IsOK(res1)) {
    21880     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_ReadFile" "', argument " "1"" of type '" "unsigned char *""'");
    21881   }
    21882   arg1 = reinterpret_cast< unsigned char * >(argp1);
    21883   ecode2 = SWIG_AsVal_int(obj1, &val2);
    21884   if (!SWIG_IsOK(ecode2)) {
    21885     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_ReadFile" "', argument " "2"" of type '" "int""'");
    21886   }
    21887   arg2 = static_cast< int >(val2);
    21888   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21889   if (!SWIG_IsOK(res3)) {
    21890     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_ReadFile" "', argument " "3"" of type '" "unsigned char *""'");
    21891   }
    21892   arg3 = reinterpret_cast< unsigned char * >(argp3);
    21893   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
    21894   if (!SWIG_IsOK(res4)) {
    21895     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_ReadFile" "', argument " "4"" of type '" "unsigned long *""'");
    21896   }
    21897   arg4 = reinterpret_cast< unsigned long * >(argp4);
    21898   ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
    21899   if (!SWIG_IsOK(ecode5)) {
    21900     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PTEID_ReadFile" "', argument " "5"" of type '" "unsigned char""'");
    21901   }
    21902   arg5 = static_cast< unsigned char >(val5);
    21903   result = (long)eIDMW::PTEID_ReadFile(arg1,arg2,arg3,arg4,arg5);
    21904   resultobj = SWIG_From_long(static_cast< long >(result));
    21905   return resultobj;
    21906 fail:
    21907   return NULL;
    21908 }
    21909 
    21910 
    21911 SWIGINTERN PyObject *_wrap_PTEID_WriteFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21912   PyObject *resultobj = 0;
    21913   unsigned char *arg1 = (unsigned char *) 0 ;
    21914   int arg2 ;
    21915   unsigned char *arg3 = (unsigned char *) 0 ;
    21916   unsigned long arg4 ;
    21917   unsigned char arg5 ;
    21918   void *argp1 = 0 ;
    21919   int res1 = 0 ;
    21920   int val2 ;
    21921   int ecode2 = 0 ;
    21922   void *argp3 = 0 ;
    21923   int res3 = 0 ;
    21924   unsigned long val4 ;
    21925   int ecode4 = 0 ;
    21926   unsigned char val5 ;
    21927   int ecode5 = 0 ;
    21928   PyObject * obj0 = 0 ;
    21929   PyObject * obj1 = 0 ;
    21930   PyObject * obj2 = 0 ;
    21931   PyObject * obj3 = 0 ;
    21932   PyObject * obj4 = 0 ;
    21933   long result;
    21934  
    21935   if(!PyArg_UnpackTuple(args,(char *)"PTEID_WriteFile",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
    21936   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21937   if (!SWIG_IsOK(res1)) {
    21938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_WriteFile" "', argument " "1"" of type '" "unsigned char *""'");
    21939   }
    21940   arg1 = reinterpret_cast< unsigned char * >(argp1);
    21941   ecode2 = SWIG_AsVal_int(obj1, &val2);
    21942   if (!SWIG_IsOK(ecode2)) {
    21943     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_WriteFile" "', argument " "2"" of type '" "int""'");
    21944   }
    21945   arg2 = static_cast< int >(val2);
    21946   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
    21947   if (!SWIG_IsOK(res3)) {
    21948     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_WriteFile" "', argument " "3"" of type '" "unsigned char *""'");
    21949   }
    21950   arg3 = reinterpret_cast< unsigned char * >(argp3);
    21951   ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
    21952   if (!SWIG_IsOK(ecode4)) {
    21953     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PTEID_WriteFile" "', argument " "4"" of type '" "unsigned long""'");
    21954   }
    21955   arg4 = static_cast< unsigned long >(val4);
    21956   ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
    21957   if (!SWIG_IsOK(ecode5)) {
    21958     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PTEID_WriteFile" "', argument " "5"" of type '" "unsigned char""'");
    21959   }
    21960   arg5 = static_cast< unsigned char >(val5);
    21961   result = (long)eIDMW::PTEID_WriteFile(arg1,arg2,arg3,arg4,arg5);
    21962   resultobj = SWIG_From_long(static_cast< long >(result));
    21963   return resultobj;
    21964 fail:
    21965   return NULL;
    21966 }
    21967 
    21968 
    21969 SWIGINTERN PyObject *_wrap_PTEID_IsActivated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21970   PyObject *resultobj = 0;
    21971   unsigned long *arg1 = (unsigned long *) 0 ;
    21972   void *argp1 = 0 ;
    21973   int res1 = 0 ;
    21974   PyObject * obj0 = 0 ;
    21975   long result;
    21976  
    21977   if(!PyArg_UnpackTuple(args,(char *)"PTEID_IsActivated",1,1,&obj0)) SWIG_fail;
    21978   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_long, 0 |  0 );
    21979   if (!SWIG_IsOK(res1)) {
    21980     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_IsActivated" "', argument " "1"" of type '" "unsigned long *""'");
    21981   }
    21982   arg1 = reinterpret_cast< unsigned long * >(argp1);
    21983   result = (long)eIDMW::PTEID_IsActivated(arg1);
    21984   resultobj = SWIG_From_long(static_cast< long >(result));
    21985   return resultobj;
    21986 fail:
    21987   return NULL;
    21988 }
    21989 
    21990 
    21991 SWIGINTERN PyObject *_wrap_PTEID_Activate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    21992   PyObject *resultobj = 0;
    21993   char *arg1 = (char *) 0 ;
    21994   unsigned char *arg2 = (unsigned char *) 0 ;
    21995   unsigned long arg3 ;
    21996   int res1 ;
    21997   char *buf1 = 0 ;
    21998   int alloc1 = 0 ;
    21999   void *argp2 = 0 ;
    22000   int res2 = 0 ;
    22001   unsigned long val3 ;
    22002   int ecode3 = 0 ;
    22003   PyObject * obj0 = 0 ;
    22004   PyObject * obj1 = 0 ;
    22005   PyObject * obj2 = 0 ;
    22006   long result;
    22007  
    22008   if(!PyArg_UnpackTuple(args,(char *)"PTEID_Activate",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
    22009   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    22010   if (!SWIG_IsOK(res1)) {
    22011     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_Activate" "', argument " "1"" of type '" "char *""'");
    22012   }
    22013   arg1 = reinterpret_cast< char * >(buf1);
    22014   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    22015   if (!SWIG_IsOK(res2)) {
    22016     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_Activate" "', argument " "2"" of type '" "unsigned char *""'");
    22017   }
    22018   arg2 = reinterpret_cast< unsigned char * >(argp2);
    22019   ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
    22020   if (!SWIG_IsOK(ecode3)) {
    22021     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PTEID_Activate" "', argument " "3"" of type '" "unsigned long""'");
    22022   }
    22023   arg3 = static_cast< unsigned long >(val3);
    22024   result = (long)eIDMW::PTEID_Activate(arg1,arg2,arg3);
    22025   resultobj = SWIG_From_long(static_cast< long >(result));
    22026   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    22027   return resultobj;
    22028 fail:
    22029   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    22030   return NULL;
    22031 }
    22032 
    22033 
    22034 SWIGINTERN PyObject *_wrap_PTEID_SetSODChecking(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22035   PyObject *resultobj = 0;
    22036   int arg1 ;
    22037   int val1 ;
    22038   int ecode1 = 0 ;
    22039   PyObject * obj0 = 0 ;
    22040   long result;
    22041  
    22042   if(!PyArg_UnpackTuple(args,(char *)"PTEID_SetSODChecking",1,1,&obj0)) SWIG_fail;
    22043   ecode1 = SWIG_AsVal_int(obj0, &val1);
    22044   if (!SWIG_IsOK(ecode1)) {
    22045     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PTEID_SetSODChecking" "', argument " "1"" of type '" "int""'");
    22046   }
    22047   arg1 = static_cast< int >(val1);
    22048   result = (long)eIDMW::PTEID_SetSODChecking(arg1);
    22049   resultobj = SWIG_From_long(static_cast< long >(result));
    22050   return resultobj;
    22051 fail:
    22052   return NULL;
    22053 }
    22054 
    22055 
    22056 SWIGINTERN PyObject *_wrap_PTEID_SetSODCAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22057   PyObject *resultobj = 0;
    22058   eIDMW::PTEID_Certifs *arg1 = (eIDMW::PTEID_Certifs *) 0 ;
    22059   void *argp1 = 0 ;
    22060   int res1 = 0 ;
    22061   PyObject * obj0 = 0 ;
    22062   long result;
    22063  
    22064   if(!PyArg_UnpackTuple(args,(char *)"PTEID_SetSODCAs",1,1,&obj0)) SWIG_fail;
    22065   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_Certifs, 0 |  0 );
    22066   if (!SWIG_IsOK(res1)) {
    22067     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_SetSODCAs" "', argument " "1"" of type '" "eIDMW::PTEID_Certifs *""'");
    22068   }
    22069   arg1 = reinterpret_cast< eIDMW::PTEID_Certifs * >(argp1);
    22070   result = (long)eIDMW::PTEID_SetSODCAs(arg1);
    22071   resultobj = SWIG_From_long(static_cast< long >(result));
    22072   return resultobj;
    22073 fail:
    22074   return NULL;
    22075 }
    22076 
    22077 
    22078 SWIGINTERN PyObject *_wrap_PTEID_GetCardAuthenticationKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22079   PyObject *resultobj = 0;
    22080   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    22081   void *argp1 = 0 ;
    22082   int res1 = 0 ;
    22083   PyObject * obj0 = 0 ;
    22084   long result;
    22085  
    22086   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetCardAuthenticationKey",1,1,&obj0)) SWIG_fail;
    22087   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    22088   if (!SWIG_IsOK(res1)) {
    22089     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetCardAuthenticationKey" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    22090   }
    22091   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    22092   result = (long)eIDMW::PTEID_GetCardAuthenticationKey(arg1);
    22093   resultobj = SWIG_From_long(static_cast< long >(result));
    22094   return resultobj;
    22095 fail:
    22096   return NULL;
    22097 }
    22098 
    22099 
    22100 SWIGINTERN PyObject *_wrap_PTEID_GetCVCRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22101   PyObject *resultobj = 0;
    22102   eIDMW::PTEID_RSAPublicKey *arg1 = (eIDMW::PTEID_RSAPublicKey *) 0 ;
    22103   void *argp1 = 0 ;
    22104   int res1 = 0 ;
    22105   PyObject * obj0 = 0 ;
    22106   long result;
    22107  
    22108   if(!PyArg_UnpackTuple(args,(char *)"PTEID_GetCVCRoot",1,1,&obj0)) SWIG_fail;
    22109   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_eIDMW__PTEID_RSAPublicKey, 0 |  0 );
    22110   if (!SWIG_IsOK(res1)) {
    22111     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_GetCVCRoot" "', argument " "1"" of type '" "eIDMW::PTEID_RSAPublicKey *""'");
    22112   }
    22113   arg1 = reinterpret_cast< eIDMW::PTEID_RSAPublicKey * >(argp1);
    22114   result = (long)eIDMW::PTEID_GetCVCRoot(arg1);
    22115   resultobj = SWIG_From_long(static_cast< long >(result));
    22116   return resultobj;
    22117 fail:
    22118   return NULL;
    22119 }
    22120 
    22121 
    22122 SWIGINTERN PyObject *_wrap_PTEID_SendAPDU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22123   PyObject *resultobj = 0;
    22124   unsigned char *arg1 = (unsigned char *) 0 ;
    22125   unsigned long arg2 ;
    22126   unsigned char *arg3 = (unsigned char *) 0 ;
    22127   unsigned long *arg4 = (unsigned long *) 0 ;
    22128   void *argp1 = 0 ;
    22129   int res1 = 0 ;
    22130   unsigned long val2 ;
    22131   int ecode2 = 0 ;
    22132   void *argp3 = 0 ;
    22133   int res3 = 0 ;
    22134   void *argp4 = 0 ;
    22135   int res4 = 0 ;
    22136   PyObject * obj0 = 0 ;
    22137   PyObject * obj1 = 0 ;
    22138   PyObject * obj2 = 0 ;
    22139   PyObject * obj3 = 0 ;
    22140   long result;
    22141  
    22142   if(!PyArg_UnpackTuple(args,(char *)"PTEID_SendAPDU",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
    22143   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
    22144   if (!SWIG_IsOK(res1)) {
    22145     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_SendAPDU" "', argument " "1"" of type '" "unsigned char const *""'");
    22146   }
    22147   arg1 = reinterpret_cast< unsigned char * >(argp1);
    22148   ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
    22149   if (!SWIG_IsOK(ecode2)) {
    22150     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PTEID_SendAPDU" "', argument " "2"" of type '" "unsigned long""'");
    22151   }
    22152   arg2 = static_cast< unsigned long >(val2);
    22153   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
    22154   if (!SWIG_IsOK(res3)) {
    22155     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PTEID_SendAPDU" "', argument " "3"" of type '" "unsigned char *""'");
    22156   }
    22157   arg3 = reinterpret_cast< unsigned char * >(argp3);
    22158   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
    22159   if (!SWIG_IsOK(res4)) {
    22160     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_SendAPDU" "', argument " "4"" of type '" "unsigned long *""'");
    22161   }
    22162   arg4 = reinterpret_cast< unsigned long * >(argp4);
    22163   result = (long)eIDMW::PTEID_SendAPDU((unsigned char const *)arg1,arg2,arg3,arg4);
    22164   resultobj = SWIG_From_long(static_cast< long >(result));
    22165   return resultobj;
    22166 fail:
    22167   return NULL;
    22168 }
    22169 
    22170 
    22171 SWIGINTERN PyObject *_wrap_PTEID_CAP_ChangeCapPin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22172   PyObject *resultobj = 0;
    22173   char *arg1 = (char *) 0 ;
    22174   unsigned char *arg2 = (unsigned char *) 0 ;
    22175   unsigned long arg3 ;
    22176   eIDMW::tProxyInfo *arg4 = (eIDMW::tProxyInfo *) 0 ;
    22177   char *arg5 = (char *) 0 ;
    22178   char *arg6 = (char *) 0 ;
    22179   long *arg7 = (long *) 0 ;
    22180   int res1 ;
    22181   char *buf1 = 0 ;
    22182   int alloc1 = 0 ;
    22183   void *argp2 = 0 ;
    22184   int res2 = 0 ;
    22185   unsigned long val3 ;
    22186   int ecode3 = 0 ;
    22187   void *argp4 = 0 ;
    22188   int res4 = 0 ;
    22189   int res5 ;
    22190   char *buf5 = 0 ;
    22191   int alloc5 = 0 ;
    22192   int res6 ;
    22193   char *buf6 = 0 ;
    22194   int alloc6 = 0 ;
    22195   void *argp7 = 0 ;
    22196   int res7 = 0 ;
    22197   PyObject * obj0 = 0 ;
    22198   PyObject * obj1 = 0 ;
    22199   PyObject * obj2 = 0 ;
    22200   PyObject * obj3 = 0 ;
    22201   PyObject * obj4 = 0 ;
    22202   PyObject * obj5 = 0 ;
    22203   PyObject * obj6 = 0 ;
    22204   long result;
    22205  
    22206   if(!PyArg_UnpackTuple(args,(char *)"PTEID_CAP_ChangeCapPin",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
    22207   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    22208   if (!SWIG_IsOK(res1)) {
    22209     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "1"" of type '" "char const *""'");
    22210   }
    22211   arg1 = reinterpret_cast< char * >(buf1);
    22212   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    22213   if (!SWIG_IsOK(res2)) {
    22214     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "2"" of type '" "unsigned char const *""'");
    22215   }
    22216   arg2 = reinterpret_cast< unsigned char * >(argp2);
    22217   ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
    22218   if (!SWIG_IsOK(ecode3)) {
    22219     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "3"" of type '" "unsigned long""'");
    22220   }
    22221   arg3 = static_cast< unsigned long >(val3);
    22222   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_eIDMW__tProxyInfo, 0 |  0 );
    22223   if (!SWIG_IsOK(res4)) {
    22224     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "4"" of type '" "eIDMW::tProxyInfo *""'");
    22225   }
    22226   arg4 = reinterpret_cast< eIDMW::tProxyInfo * >(argp4);
    22227   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
    22228   if (!SWIG_IsOK(res5)) {
    22229     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "5"" of type '" "char const *""'");
    22230   }
    22231   arg5 = reinterpret_cast< char * >(buf5);
    22232   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
    22233   if (!SWIG_IsOK(res6)) {
    22234     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "6"" of type '" "char const *""'");
    22235   }
    22236   arg6 = reinterpret_cast< char * >(buf6);
    22237   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_long, 0 |  0 );
    22238   if (!SWIG_IsOK(res7)) {
    22239     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "PTEID_CAP_ChangeCapPin" "', argument " "7"" of type '" "long *""'");
    22240   }
    22241   arg7 = reinterpret_cast< long * >(argp7);
    22242   result = (long)eIDMW::PTEID_CAP_ChangeCapPin((char const *)arg1,(unsigned char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7);
    22243   resultobj = SWIG_From_long(static_cast< long >(result));
    22244   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    22245   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
    22246   if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
    22247   return resultobj;
    22248 fail:
    22249   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    22250   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
    22251   if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
    22252   return NULL;
    22253 }
    22254 
    22255 
    22256 SWIGINTERN PyObject *_wrap_PTEID_CAP_GetCapPinChangeProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22257   PyObject *resultobj = 0;
    22258   eIDMW::tCapPinChangeState result;
    22259  
    22260   result = (eIDMW::tCapPinChangeState)eIDMW::PTEID_CAP_GetCapPinChangeProgress();
    22261   resultobj = SWIG_From_int(static_cast< int >(result));
    22262   return resultobj;
    22263 fail:
    22264   return NULL;
    22265 }
    22266 
    22267 
    22268 SWIGINTERN PyObject *_wrap_PTEID_CAP_SetCapPinChangeCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22269   PyObject *resultobj = 0;
    22270   void (*arg1)(eIDMW::tCapPinChangeState) = (void (*)(eIDMW::tCapPinChangeState)) 0 ;
    22271   PyObject * obj0 = 0 ;
    22272  
    22273   if(!PyArg_UnpackTuple(args,(char *)"PTEID_CAP_SetCapPinChangeCallback",1,1,&obj0)) SWIG_fail;
    22274   {
    22275     int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_enum_eIDMW__tCapPinChangeState__void);
    22276     if (!SWIG_IsOK(res)) {
    22277       SWIG_exception_fail(SWIG_ArgError(res), "in method '" "PTEID_CAP_SetCapPinChangeCallback" "', argument " "1"" of type '" "void (*)(eIDMW::tCapPinChangeState)""'");
    22278     }
    22279   }
    22280   eIDMW::PTEID_CAP_SetCapPinChangeCallback(arg1);
    22281   resultobj = SWIG_Py_Void();
    22282   return resultobj;
    22283 fail:
    22284   return NULL;
    22285 }
    22286 
    22287 
    22288 SWIGINTERN PyObject *_wrap_PTEID_CAP_CancelCapPinChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    22289   PyObject *resultobj = 0;
    22290  
    22291   eIDMW::PTEID_CAP_CancelCapPinChange();
    22292   resultobj = SWIG_Py_Void();
    22293   return resultobj;
    22294 fail:
    22295   return NULL;
    2229615650}
    2229715651
     
    2270916063         { (char *)"PTEID_Config_swigregister", PTEID_Config_swigregister, METH_VARARGS, NULL},
    2271016064         { (char *)"PTEID_LOG", _wrap_PTEID_LOG, METH_VARARGS, NULL},
    22711          { (char *)"PTEID_ID_version_set", _wrap_PTEID_ID_version_set, METH_VARARGS, NULL},
    22712          { (char *)"PTEID_ID_version_get", _wrap_PTEID_ID_version_get, METH_VARARGS, NULL},
    22713          { (char *)"PTEID_ID_deliveryEntity_set", _wrap_PTEID_ID_deliveryEntity_set, METH_VARARGS, NULL},
    22714          { (char *)"PTEID_ID_deliveryEntity_get", _wrap_PTEID_ID_deliveryEntity_get, METH_VARARGS, NULL},
    22715          { (char *)"PTEID_ID_country_set", _wrap_PTEID_ID_country_set, METH_VARARGS, NULL},
    22716          { (char *)"PTEID_ID_country_get", _wrap_PTEID_ID_country_get, METH_VARARGS, NULL},
    22717          { (char *)"PTEID_ID_documentType_set", _wrap_PTEID_ID_documentType_set, METH_VARARGS, NULL},
    22718          { (char *)"PTEID_ID_documentType_get", _wrap_PTEID_ID_documentType_get, METH_VARARGS, NULL},
    22719          { (char *)"PTEID_ID_cardNumber_set", _wrap_PTEID_ID_cardNumber_set, METH_VARARGS, NULL},
    22720          { (char *)"PTEID_ID_cardNumber_get", _wrap_PTEID_ID_cardNumber_get, METH_VARARGS, NULL},
    22721          { (char *)"PTEID_ID_cardNumberPAN_set", _wrap_PTEID_ID_cardNumberPAN_set, METH_VARARGS, NULL},
    22722          { (char *)"PTEID_ID_cardNumberPAN_get", _wrap_PTEID_ID_cardNumberPAN_get, METH_VARARGS, NULL},
    22723          { (char *)"PTEID_ID_cardVersion_set", _wrap_PTEID_ID_cardVersion_set, METH_VARARGS, NULL},
    22724          { (char *)"PTEID_ID_cardVersion_get", _wrap_PTEID_ID_cardVersion_get, METH_VARARGS, NULL},
    22725          { (char *)"PTEID_ID_deliveryDate_set", _wrap_PTEID_ID_deliveryDate_set, METH_VARARGS, NULL},
    22726          { (char *)"PTEID_ID_deliveryDate_get", _wrap_PTEID_ID_deliveryDate_get, METH_VARARGS, NULL},
    22727          { (char *)"PTEID_ID_locale_set", _wrap_PTEID_ID_locale_set, METH_VARARGS, NULL},
    22728          { (char *)"PTEID_ID_locale_get", _wrap_PTEID_ID_locale_get, METH_VARARGS, NULL},
    22729          { (char *)"PTEID_ID_validityDate_set", _wrap_PTEID_ID_validityDate_set, METH_VARARGS, NULL},
    22730          { (char *)"PTEID_ID_validityDate_get", _wrap_PTEID_ID_validityDate_get, METH_VARARGS, NULL},
    22731          { (char *)"PTEID_ID_name_set", _wrap_PTEID_ID_name_set, METH_VARARGS, NULL},
    22732          { (char *)"PTEID_ID_name_get", _wrap_PTEID_ID_name_get, METH_VARARGS, NULL},
    22733          { (char *)"PTEID_ID_firstname_set", _wrap_PTEID_ID_firstname_set, METH_VARARGS, NULL},
    22734          { (char *)"PTEID_ID_firstname_get", _wrap_PTEID_ID_firstname_get, METH_VARARGS, NULL},
    22735          { (char *)"PTEID_ID_sex_set", _wrap_PTEID_ID_sex_set, METH_VARARGS, NULL},
    22736          { (char *)"PTEID_ID_sex_get", _wrap_PTEID_ID_sex_get, METH_VARARGS, NULL},
    22737          { (char *)"PTEID_ID_nationality_set", _wrap_PTEID_ID_nationality_set, METH_VARARGS, NULL},
    22738          { (char *)"PTEID_ID_nationality_get", _wrap_PTEID_ID_nationality_get, METH_VARARGS, NULL},
    22739          { (char *)"PTEID_ID_birthDate_set", _wrap_PTEID_ID_birthDate_set, METH_VARARGS, NULL},
    22740          { (char *)"PTEID_ID_birthDate_get", _wrap_PTEID_ID_birthDate_get, METH_VARARGS, NULL},
    22741          { (char *)"PTEID_ID_height_set", _wrap_PTEID_ID_height_set, METH_VARARGS, NULL},
    22742          { (char *)"PTEID_ID_height_get", _wrap_PTEID_ID_height_get, METH_VARARGS, NULL},
    22743          { (char *)"PTEID_ID_numBI_set", _wrap_PTEID_ID_numBI_set, METH_VARARGS, NULL},
    22744          { (char *)"PTEID_ID_numBI_get", _wrap_PTEID_ID_numBI_get, METH_VARARGS, NULL},
    22745          { (char *)"PTEID_ID_nameFather_set", _wrap_PTEID_ID_nameFather_set, METH_VARARGS, NULL},
    22746          { (char *)"PTEID_ID_nameFather_get", _wrap_PTEID_ID_nameFather_get, METH_VARARGS, NULL},
    22747          { (char *)"PTEID_ID_firstnameFather_set", _wrap_PTEID_ID_firstnameFather_set, METH_VARARGS, NULL},
    22748          { (char *)"PTEID_ID_firstnameFather_get", _wrap_PTEID_ID_firstnameFather_get, METH_VARARGS, NULL},
    22749          { (char *)"PTEID_ID_nameMother_set", _wrap_PTEID_ID_nameMother_set, METH_VARARGS, NULL},
    22750          { (char *)"PTEID_ID_nameMother_get", _wrap_PTEID_ID